movie/node_modules/@rateyo/jquery/lib/es/jquery.rateyo.js

import $$1 from 'jquery';

function _typeof(obj) {
  "@babel/helpers - typeof";

  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    _typeof = function (obj) {
      return typeof obj;
    };
  } else {
    _typeof = function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
  }

  return _typeof(obj);
}

function _typeof$1(obj) {
  "@babel/helpers - typeof";

  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    _typeof$1 = function (obj) {
      return typeof obj;
    };
  } else {
    _typeof$1 = function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
  }

  return _typeof$1(obj);
}

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    if (enumerableOnly) symbols = symbols.filter(function (sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    });
    keys.push.apply(keys, symbols);
  }

  return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKeys(Object(source), true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
}

// The basic svg string required to generate stars
var BASICSTAR = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" + "<svg version=\"1.1\"" + "xmlns=\"http://www.w3.org/2000/svg\"" + "viewBox=\"0 12.705 512 486.59\"" + "x=\"0px\" y=\"0px\"" + "xml:space=\"preserve\">" + "<polygon " + "points=\"256.814,12.705 317.205,198.566" + " 512.631,198.566 354.529,313.435 " + "414.918,499.295 256.814,384.427 " + "98.713,499.295 159.102,313.435 " + "1,198.566 196.426,198.566 \"/>" + "</svg>"; // The Default values of different options available in the Plugin

var DEFAULTS = {
  starWidth: "32px",
  normalFill: "gray",
  ratedFill: "#f39c12",
  numStars: 5,
  maxValue: 5,
  precision: 1,
  rating: 0,
  fullStar: false,
  halfStar: false,
  hover: true,
  readOnly: false,
  spacing: "0px",
  rtl: false,
  multiColor: null,
  onInit: null,
  onChange: null,
  onSet: null,
  starSvg: null
}; //Default colors for multi-color rating

var MULTICOLOR_OPTIONS = {
  startColor: "#c0392b",
  //red
  endColor: "#f1c40f" //yellow

};

// http://stackoverflow.com/questions/11381673/detecting-a-mobile-browser
function isMobileBrowser() {
  var check = false;

  (function (a) {
    if (/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ipad|playbook|silk/i.test(a) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(a.substr(0, 4))) check = true;
  })(navigator.userAgent || navigator.vendor || window.opera);

  return check;
}
function checkPrecision(value, minValue, maxValue) {
  /*
   * This function removes the unnecessary precision, at Min and Max Values
   */
  // Its like comparing 0.0 with 0, which is true
  if (value === minValue) {
    value = minValue;
  } else if (value === maxValue) {
    value = maxValue;
  }

  return value;
}
function checkBounds(value, minValue, maxValue) {
  /*
   * Check if the value is between min and max values, if not, throw an error
   */
  var isValid = value >= minValue && value <= maxValue;

  if (!isValid) {
    throw Error("Invalid Rating, expected value between " + minValue + " and " + maxValue);
  }

  return value;
}

function isType(value, type) {
  return _typeof$1(value) === type;
}

function isDefined(value) {
  // Better way to check if a variable is defined or not
  return typeof value !== "undefined";
}
var isNumber = function isNumber(input) {
  return isType(input, "number");
};
var isString = function isString(input) {
  return isType(input, "string");
};
var isFunction = function isFunction(input) {
  return isType(input, "function");
};

var hexRegex = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i;

function hexToRGB(hex) {
  /*
   * Extracts and returns the Red, Blue, Green Channel values,
   * in the form of decimals
   */
  if (!hexRegex.test(hex)) {
    return null;
  }

  var hexValues = hexRegex.exec(hex),
      r = parseInt(hexValues[1], 16),
      g = parseInt(hexValues[2], 16),
      b = parseInt(hexValues[3], 16);
  return {
    r: r,
    g: g,
    b: b
  };
}

function getChannelValue(startVal, endVal, percent) {
  /*
   * Returns a value between `startVal` and `endVal` based on the percent
   */
  var newVal = (endVal - startVal) * (percent / 100);
  newVal = Math.round(startVal + newVal).toString(16);

  if (newVal.length === 1) {
    newVal = "0" + newVal;
  }

  return newVal;
}

function getColor(startColor, endColor, percent) {
  /*
   * Given the percentage( `percent` ) of `endColor` to be mixed
   * with the `startColor`, returns the mixed color.
   * Colors should be only in Hex Format
   */
  if (!startColor || !endColor) {
    return null;
  }

  percent = isDefined(percent) ? percent : 0;
  startColor = hexToRGB(startColor);
  endColor = hexToRGB(endColor);
  var r = getChannelValue(startColor.r, endColor.r, percent),
      b = getChannelValue(startColor.b, endColor.b, percent),
      g = getChannelValue(startColor.g, endColor.g, percent);
  return "#" + r + g + b;
}

var eventObjectMap = {};

function getEventObject(event) {
  return eventObjectMap[event] || (eventObjectMap[event] = new String(event));
}
var handlerProxyMap = new WeakMap();

function proxy(node, fn, event) {
  event = getEventObject(event);
  var eventHandlerMap = handlerProxyMap.get(node);

  if (!eventHandlerMap) {
    handlerProxyMap.set(node, eventHandlerMap = new WeakMap());
  }

  var handlerMap = eventHandlerMap.get(event);

  if (!handlerMap) {
    eventHandlerMap.set(event, handlerMap = new Map());
  }

  var handler = handlerMap.get(fn);

  if (handler) {
    return handler;
  }

  function proxy(e) {
    var data = e.detail;
    fn.call(node, e, data);
  }

  handlerMap.set(fn, proxy);
  return proxy;
}

proxy.get = function getOriginalFunction(node, fn, event) {
  event = getEventObject(event);
  var eventHandlerMap = handlerProxyMap.get(node);

  if (!eventHandlerMap) {
    return fn;
  }

  var handlerMap = eventHandlerMap.get(event);

  if (!handlerMap) {
    return fn;
  }

  return handlerMap.get(fn) || fn;
};

var Event = isFunction(window.Event) ? window.Event : function Event(event) {
  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var _params$bubbles = params.bubbles,
      bubbles = _params$bubbles === void 0 ? false : _params$bubbles,
      _params$cancelable = params.cancelable,
      cancelable = _params$cancelable === void 0 ? false : _params$cancelable;
  var evt = document.createEvent("Event");
  evt.initEvent(event, bubbles, cancelable);
  return evt;
};
var CustomEvent = isFunction(window.CustomEvent) ? window.CustomEvent : (CustomEvent.prototype = Object.create(Event.prototype), CustomEvent);
var events = {
  trigger: function trigger(event, detail) {
    var eventProps = {
      bubbles: true
    };

    if (!isDefined(detail)) {
      this.node.dispatchEvent(new Event(event, eventProps));
    } else {
      this.node.dispatchEvent(new CustomEvent(event, _objectSpread2({
        detail: detail
      }, eventProps)));
    }

    return this;
  },
  on: function on(event, handler) {
    this.node.addEventListener(event, proxy(this.node, handler, event));
    return this;
  },
  off: function off(event, handler) {
    this.node.removeEventListener(event, proxy.get(this.node, handler, event));
    return this;
  }
};

var rateyoAttrRegex = /^rateyo(.+)$/;

function classList(node, operation, input) {
  var className = node.className.trim();
  var classes = className && className.split(/\s/) || [],
      classMap = {};
  classes = classes.reduce(function (result, item, index) {
    if (!classMap.hasOwnProperty(item)) {
      result.push(item);
      classMap[item] = index;
    }

    return result;
  }, []);

  if (operation === classList.add) {
    if (classMap.hasOwnProperty(input)) {
      return;
    }

    classes.push(input);
  } else if (operation === classList.remove) {
    if (!classMap.hasOwnProperty(input)) {
      return;
    }

    classes.splice(classMap[input], 1);
  }

  node.className = classes.join(" ");
}

classList.add = "add";
classList.remove = "remove";

function El(node) {
  this.node = node;
}

El.prototype = {
  empty: function empty() {
    this.node.innerHTML = "";
    return this;
  },
  addClass: function addClass(className) {
    classList(this.node, classList.add, className);
    return this;
  },
  removeClass: function removeClass(className) {
    classList(this.node, classList.remove, className);
    return this;
  },
  appendTo: function appendTo(parent) {
    (El.isEl(parent) ? parent.node : parent).appendChild(this.node);
    return this;
  },
  css: function css(styleAttribute, value) {
    this.node.style[styleAttribute] = value;
    return this;
  },
  width: function width(_width) {
    if (!isDefined(_width)) {
      return this.node.getBoundingClientRect().width;
    }

    this.css("width", _width + (isNumber(_width) ? "px" : ""));
  },
  find: function find(selector) {
    return $(this.node.querySelectorAll(selector));
  },
  attr: function attr(attrObj) {
    for (var attrName in attrObj) {
      if (attrObj.hasOwnProperty(attrName)) {
        this.node.setAttribute(attrName, attrObj[attrName]);
      }
    }

    return this;
  },
  removeAttr: function removeAttr(attributeName) {
    this.node.removeAttribute(attributeName);
    return this;
  },
  children: function children() {
    return $(this.node.childNodes);
  },
  remove: function remove() {
    return this.node.remove();
  },
  offset: function offset() {
    var _this$node$getBoundin = this.node.getBoundingClientRect(),
        top = _this$node$getBoundin.top,
        left = _this$node$getBoundin.left,
        bottom = _this$node$getBoundin.bottom,
        right = _this$node$getBoundin.right;

    return {
      top: top,
      left: left,
      bottom: bottom,
      right: right
    };
  },
  dataAttrOptions: function dataAttrOptions() {
    var dataset = this.node.dataset;
    return Object.keys(dataset).reduce(function (options, attr) {
      var match = attr.match(rateyoAttrRegex);

      if (!match) {
        return options;
      }

      var rateyoAttr = match[1],
          option = rateyoAttr[0].toLowerCase() + rateyoAttr.slice(1);
      options[option] = dataset[attr];
      return options;
    }, {});
  }
};
El.prototype = _objectSpread2(_objectSpread2({}, El.prototype), events);

El.isEl = function (node) {
  return node instanceof El;
};

function Collection(nodeList) {
  var _this = this;

  this.collection = [];
  Array.prototype.forEach.call(nodeList, function (node) {
    _this.collection.push(new El(node));
  });
}

Collection.isCollection = function (input) {
  return input instanceof Collection;
};

Collection.prototype = {};

var _loop = function _loop(method) {
  if (!El.prototype.hasOwnProperty(method)) {
    return "continue";
  }

  function proxy() {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    this.collection.forEach(function (el) {
      return El.isEl(el) && el[method].apply(el, args);
    });
    return this;
  }

  Collection.prototype[method] = proxy;
};

for (var method in El.prototype) {
  var _ret = _loop(method);

  if (_ret === "continue") continue;
}

var parser = new DOMParser();

function parseHTML(html) {
  return parser.parseFromString(html.trim(), "text/html").body.childNodes;
}

function $(node) {
  node = isString(node) && parseHTML(node) || node;

  if (El.isEl(node) || Collection.isCollection(node)) {
    return node;
  }

  if (node instanceof NodeList) {
    return new Collection(node);
  }

  return new El(node);
}

$.El = El;

var instanceMap = new WeakMap();

function RateYo(node) {
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

  if (!(this instanceof RateYo)) {
    return new RateYo(node, options);
  }

  if (instanceMap.has(node)) {
    return instanceMap.get(node);
  }

  var that = this;
  this.node = node;
  var $node = $(node);
  options = _objectSpread2(_objectSpread2(_objectSpread2({}, DEFAULTS), options), $node.dataAttrOptions()); // Remove any stuff that is present inside the container, and add the plugin class

  $node.empty().addClass("jq-ry-container");
  /*
   * Basically the plugin displays the rating using two rows of stars lying one above
   * the other, the row that is on the top represents the actual rating, and the one
   * behind acts just like a background.
   *
   * `$groupWrapper`: is an element that wraps both the rows
   * `$normalGroup`: is the container for row of stars thats behind and
   *                 acts as background
   * `$ratedGroup`: is the container for row of stars that display the actual rating.
   *
   * The rating is displayed by adjusting the width of `$ratedGroup`
   */

  var $groupWrapper = $(document.createElement("div")).addClass("jq-ry-group-wrapper").appendTo($node);
  var $normalGroup = $(document.createElement("div")).addClass("jq-ry-normal-group").addClass("jq-ry-group").appendTo($groupWrapper);
  var $ratedGroup = $(document.createElement("div")).addClass("jq-ry-rated-group").addClass("jq-ry-group").appendTo($groupWrapper);
  /*
   * Variable `step`: store the value of the rating for each star
   *                  eg: if `maxValue` is 5 and `numStars` is 5, value of each star
   *                      is 1.
   * Variable `starWidth`: stores the decimal value of width of star in units of px
   * Variable `percentOfStar`: stores the percentage of width each star takes w.r.t
   *                           the container
   * Variable `spacing`: stores the decimal value of the spacing between stars
   *                     in the units of px
   * Variable `percentOfSpacing`: stores the percentage of width of the spacing
   *                              between stars w.r.t the container
   */

  var step,
      starWidth,
      percentOfStar,
      spacing,
      percentOfSpacing,
      containerWidth,
      minValue = 0;
  /*
   * `currentRating` contains rating that is being displayed at the latest point of
   * time.
   *
   * When ever you hover over the plugin UI, the rating value changes
   * according to the place where you point the cursor, currentRating contains
   * the current value of rating that is being shown in the UI
   */

  var currentRating = options.rating; // A flag to store if the plugin is already being displayed in the UI

  var isInitialized = false;

  function showRating(ratingVal) {
    /*
     * The function is responsible for displaying the rating by changing
     * the width of `$ratedGroup`
     */
    if (!isDefined(ratingVal)) {
      ratingVal = options.rating;
    } // Storing the value that is being shown in `currentRating`.


    currentRating = ratingVal;
    var numStarsToShow = ratingVal / step; // calculating the percentage of width of $ratedGroup with respect to its parent

    var percent = numStarsToShow * percentOfStar;

    if (numStarsToShow > 1) {
      // adding the percentage of space that is taken by the gap the stars
      percent += (Math.ceil(numStarsToShow) - 1) * percentOfSpacing;
    }

    setRatedFill(options.ratedFill);
    percent = options.rtl ? 100 - percent : percent;

    if (percent < 0) {
      percent = 0;
    } else if (percent > 100) {
      percent = 100;
    }

    $ratedGroup.css("width", percent + "%");
  }

  function setContainerWidth() {
    /*
     * Set the width of the `this.node` based on the width of each star and
     * the space between them
     */
    containerWidth = starWidth * options.numStars + spacing * (options.numStars - 1);
    percentOfStar = starWidth / containerWidth * 100;
    percentOfSpacing = spacing / containerWidth * 100;
    $node.width(containerWidth);
    showRating();
  }

  function setStarWidth(newWidth) {
    /*
     * Set the width and height of each SVG star, called whenever one changes the
     * `starWidth` option
     */
    // The width and height of the star should be the same
    var starHeight = options.starWidth = newWidth;
    starWidth = window.parseFloat(options.starWidth.replace("px", ""));
    $normalGroup.find("svg").attr({
      width: options.starWidth,
      height: starHeight
    });
    $ratedGroup.find("svg").attr({
      width: options.starWidth,
      height: starHeight
    });
    setContainerWidth();
    return $node;
  }

  function setSpacing(newSpacing) {
    /*
     * Set spacing between the SVG stars, called whenever one changes
     * the `spacing` option
     */
    options.spacing = newSpacing;
    spacing = parseFloat(options.spacing.replace("px", ""));
    $normalGroup.find("svg:not(:first-child)").css("margin-left", newSpacing);
    $ratedGroup.find("svg:not(:first-child)").css("margin-left", newSpacing);
    setContainerWidth();
    return $node;
  }

  function setNormalFill(newFill) {
    /*
     * Set the background fill of the Stars, called whenever one changes the
     * `normalFill` option
     */
    options.normalFill = newFill;
    var $svgs = (options.rtl ? $ratedGroup : $normalGroup).find("svg");
    $svgs.attr({
      fill: options.normalFill
    });
    return $node;
  }
  /*
   * Store the recent `ratedFill` option in a variable
   * so that if multiColor is unset, we can use the perviously set `ratedFill`
   * from this variable
   */


  var ratedFill = options.ratedFill;

  function setRatedFill(newFill) {
    /*
     * Set ratedFill of the stars, called when one changes the `ratedFill` option
     */

    /*
     * If `multiColor` option is set, `newFill` variable is dynamically set
     * based on the rating, what ever set as parameter will be discarded
     */
    if (options.multiColor) {
      var ratingDiff = currentRating - minValue,
          percentCovered = ratingDiff / options.maxValue * 100;
      var colorOpts = options.multiColor || {},
          startColor = colorOpts.startColor || MULTICOLOR_OPTIONS.startColor,
          endColor = colorOpts.endColor || MULTICOLOR_OPTIONS.endColor;
      newFill = getColor(startColor, endColor, percentCovered);
    } else {
      ratedFill = newFill;
    }

    options.ratedFill = newFill;
    var $svgs = (options.rtl ? $normalGroup : $ratedGroup).find("svg");
    $svgs.attr({
      fill: options.ratedFill
    });
    return $node;
  }

  function setRtl(newValue) {
    newValue = !!newValue;
    options.rtl = newValue;
    setNormalFill(options.normalFill);
    showRating();
  }

  function setMultiColor(colorOptions) {
    /*
     * called whenever one changes the `multiColor` option
     */
    options.multiColor = colorOptions; // set the recently set `ratedFill` option, if multiColor Options are unset

    setRatedFill(colorOptions ? colorOptions : ratedFill);
  }

  function setNumStars(newValue) {
    /*
     * Set the number of stars to use to display the rating, called whenever one
     * changes the `numStars` option
     */
    options.numStars = newValue;
    step = options.maxValue / options.numStars;
    $normalGroup.empty();
    $ratedGroup.empty();

    for (var i = 0; i < options.numStars; i++) {
      $(options.starSvg || BASICSTAR).appendTo($normalGroup);
      $(options.starSvg || BASICSTAR).appendTo($ratedGroup);
    }

    setStarWidth(options.starWidth);
    setNormalFill(options.normalFill);
    setSpacing(options.spacing);
    showRating();
    return $node;
  }

  function setMaxValue(newValue) {
    /*
     * set the Maximum Value of rating to be allowed, called whenever
     * one changes the `maxValue` option
     */
    options.maxValue = newValue;
    step = options.maxValue / options.numStars;

    if (options.rating > newValue) {
      setRating(newValue);
    }

    showRating();
    return $node;
  }

  function setPrecision(newValue) {
    /*
     * Set the precision of the rating value, called if one changes the
     * `precision` option
     */
    options.precision = newValue;
    setRating(options.rating);
    return $node;
  }

  function setHalfStar(newValue) {
    /*
     * This function will be called if one changes the `halfStar` option
     */
    options.halfStar = newValue;
    return $node;
  }

  function setFullStar(newValue) {
    /*
     * This function will be called if one changes the `fullStar` option
     */
    options.fullStar = newValue;
    return $node;
  }

  function round(value) {
    /*
     * Rounds the value of rating if `halfStar` or `fullStar` options are chosen
     */
    var remainder = value % step,
        halfStep = step / 2,
        isHalfStar = options.halfStar,
        isFullStar = options.fullStar;

    if (!isFullStar && !isHalfStar) {
      return value;
    }

    if (isFullStar || isHalfStar && remainder > halfStep) {
      value += step - remainder;
    } else {
      value = value - remainder;

      if (remainder > 0) {
        value += halfStep;
      }
    }

    return value;
  }

  function calculateRating(e) {
    /*
     * Calculates and returns the rating based on the position of cursor w.r.t the
     * plugin container
     */
    var position = $normalGroup.offset(),
        nodeStartX = position.left,
        nodeEndX = nodeStartX + $normalGroup.width();
    var maxValue = options.maxValue; // The x-coordinate(position) of the mouse pointer w.r.t page

    var pageX = e.pageX;
    var calculatedRating = 0; // If the mouse pointer is to the left of the container

    if (pageX < nodeStartX) {
      calculatedRating = minValue;
    } else if (pageX > nodeEndX) {
      // If the mouse pointer is right of the container
      calculatedRating = maxValue;
    } else {
      // If the mouse pointer is inside the continer

      /*
       * The fraction of width covered by the pointer w.r.t to the total width
       * of the container.
       */
      var calcPrcnt = (pageX - nodeStartX) / (nodeEndX - nodeStartX);

      if (spacing > 0) {
        /*
         * If there is spacing between stars, take the percentage of width covered
         * and subtract the percentage of width covered by stars and spacing, to find
         * how many stars are covered, the number of stars covered is the rating
         *
         * TODO: I strongly feel that this logic can be improved!, Please help!
         */
        calcPrcnt *= 100;
        var remPrcnt = calcPrcnt;

        while (remPrcnt > 0) {
          if (remPrcnt > percentOfStar) {
            calculatedRating += step;
            remPrcnt -= percentOfStar + percentOfSpacing;
          } else {
            calculatedRating += remPrcnt / percentOfStar * step;
            remPrcnt = 0;
          }
        }
      } else {
        /*
         * If there is not spacing between stars, the fraction of width covered per
         * `maxValue` is the rating
         */
        calculatedRating = calcPrcnt * options.maxValue;
      } // Round the rating if `halfStar` or `fullStar` options are chosen


      calculatedRating = round(calculatedRating);
    }

    if (options.rtl) {
      calculatedRating = maxValue - calculatedRating;
    }

    return parseFloat(calculatedRating);
  }

  function setReadOnly(newValue) {
    /*
     * UnBinds mouse event handlers, called when whenever one changes the
     * `readOnly` option
     */
    options.readOnly = newValue;
    $node.attr({
      "readonly": true
    });
    unbindEvents();

    if (!newValue) {
      $node.removeAttr("readonly");
      bindEvents();
    }

    return $node;
  }

  function setRating(newValue) {
    /*
     * Sets the rating of the Plugin, Called when option `rating` is changed
     * or, when `rating` method is called
     */
    var rating = newValue;
    var maxValue = options.maxValue;

    if (typeof rating === "string") {
      // If rating is given in percentage, maxValue should be 100
      if (rating[rating.length - 1] === "%") {
        rating = rating.substr(0, rating.length - 1);
        maxValue = 100;
        setMaxValue(maxValue);
      }

      rating = parseFloat(rating);
    }

    checkBounds(rating, minValue, maxValue);
    rating = parseFloat(rating.toFixed(options.precision));
    checkPrecision(parseFloat(rating), minValue, maxValue);
    options.rating = rating;
    showRating();

    if (isInitialized) {
      $node.trigger("rateyo.set", {
        rating: rating
      });
    }

    return $node;
  }

  function setOnInit(method) {
    /*
     * set what method to be called on Initialization
     */
    options.onInit = method;
    return $node;
  }

  function setOnSet(method) {
    /*
     * set what method to be called when rating is set
     */
    options.onSet = method;
    return $node;
  }

  function setOnChange(method) {
    /*
     * set what method to be called rating in the UI is changed
     */
    options.onChange = method;
    return $node;
  }

  this.rating = function (newValue) {
    /*
     * rating getter/setter
     */
    if (!isDefined(newValue)) {
      return options.rating;
    }

    setRating(newValue);
    return $node;
  };

  this.destroy = function () {
    /*
     * Removes the Rating UI by clearing the content, and removing the custom classes
     */
    if (!options.readOnly) {
      unbindEvents();
    }

    instanceMap["delete"](node);
    $node.removeClass("jq-ry-container").children().remove();
    return $node;
  };

  this.method = function (methodName) {
    /*
     * Method to call the methods of RateYo Instance
     */
    if (!methodName) {
      throw Error("Method name not specified!");
    }

    if (!isDefined(this[methodName])) {
      throw Error("Method " + methodName + " doesn't exist!");
    }

    var args = Array.prototype.slice.apply(arguments, []),
        params = args.slice(1),
        method = this[methodName];
    return method.apply(this, params);
  };

  this.option = function (optionName, param) {
    /*
     * Method to get/set Options
     */
    if (!isDefined(optionName)) {
      return options;
    }

    var method;

    switch (optionName) {
      case "starWidth":
        method = setStarWidth;
        break;

      case "numStars":
        method = setNumStars;
        break;

      case "normalFill":
        method = setNormalFill;
        break;

      case "ratedFill":
        method = setRatedFill;
        break;

      case "multiColor":
        method = setMultiColor;
        break;

      case "maxValue":
        method = setMaxValue;
        break;

      case "precision":
        method = setPrecision;
        break;

      case "rating":
        method = setRating;
        break;

      case "halfStar":
        method = setHalfStar;
        break;

      case "fullStar":
        method = setFullStar;
        break;

      case "readOnly":
        method = setReadOnly;
        break;

      case "spacing":
        method = setSpacing;
        break;

      case "rtl":
        method = setRtl;
        break;

      case "onInit":
        method = setOnInit;
        break;

      case "onSet":
        method = setOnSet;
        break;

      case "onChange":
        method = setOnChange;
        break;

      default:
        throw Error("No such option as " + optionName);
    }

    return isDefined(param) ? method(param) : options[optionName];
  };

  function onMouseEnter(e) {
    if (!options.hover) {
      return;
    }
    /*
     * If the Mouse Pointer is inside the container, calculate and show the rating
     * in UI
     */


    var rating = calculateRating(e).toFixed(options.precision);
    var maxValue = options.maxValue;
    rating = checkPrecision(parseFloat(rating), minValue, maxValue);
    showRating(rating);
    $node.trigger("rateyo.change", {
      rating: rating
    });
  }

  function onMouseLeave() {
    if (isMobileBrowser() || !options.hover) {
      return;
    }
    /*
     * If mouse leaves, revert the rating in UI to previously set rating,
     * when empty value is passed to showRating, it will take the previously set
     * rating
     */


    showRating();
    $node.trigger("rateyo.change", {
      rating: options.rating
    });
  }

  function onMouseClick(e) {
    /*
     * On clicking the mouse inside the container, calculate and set the rating
     */
    var resultantRating = calculateRating(e).toFixed(options.precision);
    resultantRating = parseFloat(resultantRating);
    that.rating(resultantRating);
  }

  function onInit(e, data) {
    if (options.onInit && typeof options.onInit === "function") {
      options.onInit.apply(this, [data.rating, that]);
    }
  }

  function onChange(e, data) {
    if (options.onChange && typeof options.onChange === "function") {
      options.onChange.apply(this, [data.rating, that]);
    }
  }

  function onSet(e, data) {
    if (options.onSet && typeof options.onSet === "function") {
      options.onSet.apply(this, [data.rating, that]);
    }
  }

  function bindEvents() {
    $node.on("mousemove", onMouseEnter).on("mouseenter", onMouseEnter).on("mouseleave", onMouseLeave).on("click", onMouseClick).on("rateyo.init", onInit).on("rateyo.change", onChange).on("rateyo.set", onSet);
  }

  function unbindEvents() {
    $node.off("mousemove", onMouseEnter).off("mouseenter", onMouseEnter).off("mouseleave", onMouseLeave).off("click", onMouseClick).off("rateyo.init", onInit).off("rateyo.change", onChange).off("rateyo.set", onSet);
  }

  setNumStars(options.numStars);
  setReadOnly(options.readOnly);

  if (options.rtl) {
    setRtl(options.rtl);
  }

  instanceMap.set(node, this);
  this.rating(options.rating, true);
  isInitialized = true;
  $node.trigger("rateyo.init", {
    rating: options.rating
  });
}

Object.defineProperty(RateYo.prototype, "on", {
  value: function on(eventName, handler) {
    $(this.node).on(eventName, handler);
    return this;
  }
});
Object.defineProperty(RateYo.prototype, "off", {
  value: function off(eventName, handler) {
    $(this.node).off(eventName, handler);
    return this;
  }
});
Object.defineProperty(RateYo, "has", {
  value: function has(node) {
    return instanceMap.has(node);
  }
});
Object.defineProperty(RateYo, "get", {
  value: function get(node) {
    return instanceMap.get(node);
  }
});
Object.defineProperty(RateYo, "_$", {
  get: function get() {
    return $;
  }
});

var dollar = RateYo._$;
var eventsTrigger = dollar.El.prototype.trigger;

dollar.El.prototype.trigger = function overrideTrigger() {
  var _$;

  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  eventsTrigger.apply(this, args); // seems like jquery .on() does not handle custom events
  // also handlers registered using .addEventListener will not
  // be called when event is triggered using .trigger()
  // triggering with jquery .trigger() again for those handlers
  // registered using 

  (_$ = $$1(this.node)).trigger.apply(_$, args);
};

function _rateYo(options) {
  /* jshint validthis:true */
  var $nodes = $$1(this);

  if ($nodes.length === 0) {
    return $nodes;
  }

  var args = Array.prototype.slice.apply(arguments, []);

  if (args.length === 0) {
    //If args length is 0, Initialize the UI with default settings
    options = args[0] = {};
  } else if (args.length === 1 && _typeof(args[0]) === "object") {
    //If an Object is specified as first argument, it is considered as options
    options = args[0];
  } else if (args.length >= 1 && typeof args[0] === "string") {
    /*
     * if there is only one argument, and if its a string, it is supposed to be a
     * method name, if more than one argument is specified, the remaining arguments
     * except the first argument, will be passed as a params to the specified method
     */
    var methodName = args[0],
        params = args.slice(1);
    var result = [];
    $$1.each($nodes, function (i, node) {
      var existingInstance = RateYo.get(node);

      if (!existingInstance) {
        throw Error("Trying to set options before even initialization");
      }

      var method = existingInstance[methodName];

      if (!method) {
        throw Error("Method " + methodName + " does not exist!");
      }

      var returnVal = method.apply(existingInstance, params);
      result.push(returnVal);
    });
    /*
     * If the plugin in being called on only one jQuery Element, return only the
     * first value, to support chaining.
     */

    result = result.length === 1 ? result[0] : result;
    return result;
  } else {
    throw Error("Invalid Arguments");
  }

  return $$1.each($nodes, function () {
    return new RateYo(this, $$1.extend({}, options));
  });
}

function rateYo() {
  /* jshint validthis:true */
  return _rateYo.apply(this, Array.prototype.slice.apply(arguments, []));
}

$$1.fn.rateYo = rateYo;