jquerypp.js

/*!
* jQuery++ - 1.0.1 (2013-02-06)
* http://jquerypp.com
* Copyright (c) 2013 Bitovi
* Licensed MIT
*/
(function (window, $, undefined) {

  var getComputedStyle = document.defaultView && document.defaultView.getComputedStyle,

    rupper = /([A-Z])/g,
    rdashAlpha = /-([a-z])/ig,
    fcamelCase = function (all, letter) {
      return letter.toUpperCase();
    },

    getStyle = function (elem) {
      if (getComputedStyle) {
        return getComputedStyle(elem, null);
      }
      else if (elem.currentStyle) {
        return elem.currentStyle;
      }
    },

    rfloat = /float/i,
    rnumpx = /^-?\d+(?:px)?$/i,
    rnum = /^-?\d/;

  $.styles = function (el, styles) {
    if (!el) {
      return null;
    }
    var currentS = getStyle(el),
      oldName, val, style = el.style,
      results = {},
      i = 0,
      left, rsLeft, camelCase, name;

    for (; i < styles.length; i++) {
      name = styles[i];
      oldName = name.replace(rdashAlpha, fcamelCase);

      if (rfloat.test(name)) {
        name = $.support.cssFloat ? "float" : "styleFloat";
        oldName = "cssFloat";
      }

      if (getComputedStyle) {

        name = name.replace(rupper, "-$1").toLowerCase();

        val = currentS.getPropertyValue(name);

        if (name === "opacity" && val === "") {
          val = "1";
        }
        results[oldName] = val;
      } else {

        camelCase = name.replace(rdashAlpha, fcamelCase);
        results[oldName] = currentS[name] || currentS[camelCase];

        if (!rnumpx.test(results[oldName]) && rnum.test(results[oldName])) {

          left = style.left;
          rsLeft = el.runtimeStyle.left;

          el.runtimeStyle.left = el.currentStyle.left;
          style.left = camelCase === "fontSize" ? "1em" : (results[oldName] || 0);
          results[oldName] = style.pixelLeft + "px";

          style.left = left;
          el.runtimeStyle.left = rsLeft;
        }

      }
    }

    return results;
  };


  $.fn.styles = function () {

    return $.styles(this[0], $.makeArray(arguments));
  };

  var

  animationNum = 0,

    styleSheet = null,

    cache = [],

    browser = null,

    oldanimate = $.fn.animate,

    getStyleSheet = function () {
      if (!styleSheet) {
        var style = document.createElement('style');
        style.setAttribute("type", "text/css");
        style.setAttribute("media", "screen");

        document.getElementsByTagName('head')[0].appendChild(style);
        if (!window.createPopup) {
          style.appendChild(document.createTextNode(''));
        }

        styleSheet = style.sheet;
      }

      return styleSheet;
    },

    removeAnimation = function (sheet, name) {
      for (var j = sheet.cssRules.length - 1; j >= 0; j--) {
        var rule = sheet.cssRules[j];

        if (rule.type === 7 && rule.name == name) {
          sheet.deleteRule(j)
          return;
        }
      }
    },

    passThrough = function (props, ops) {
      var nonElement = !(this[0] && this[0].nodeType),
        isInline = !nonElement && $(this).css("display") === "inline" && $(this).css("float") === "none";

      for (var name in props) {

        if (props[name] == 'show' || props[name] == 'hide' || props[name] == 'toggle'

        || $.isArray(props[name])

        || props[name] < 0

        || name == 'zIndex' || name == 'z-index' || name == 'scrollTop' || name == 'scrollLeft') {
          return true;
        }
      }

      return props.jquery === true || getBrowser() === null ||

      $.isEmptyObject(props) ||

      (ops && ops.length == 4) || (ops && typeof ops[2] == 'string') ||

      $.isPlainObject(ops) ||

      isInline || nonElement;
    },

    cssValue = function (origName, value) {
      if (typeof value === "number" && !$.cssNumber[origName]) {
        return value += "px";
      }
      return value;
    },

    getBrowser = function () {
      if (!browser) {
        var t, el = document.createElement('fakeelement'),
          transitions = {
            'transition': {
              transitionEnd: 'transitionEnd',
              prefix: ''
            },

            'MozTransition': {
              transitionEnd: 'animationend',
              prefix: '-moz-'
            },
            'WebkitTransition': {
              transitionEnd: 'webkitAnimationEnd',
              prefix: '-webkit-'
            }
          }

          for (t in transitions) {
            if (el.style[t] !== undefined) {
              browser = transitions[t];
            }
          }
      }
      return browser;
    },

    ffProps = {
      top: function (el) {
        return el.position().top;
      },
      left: function (el) {
        return el.position().left;
      },
      width: function (el) {
        return el.width();
      },
      height: function (el) {
        return el.height();
      },
      fontSize: function (el) {
        return '1em';
      }
    },

    addPrefix = function (properties) {
      var result = {};
      $.each(properties, function (name, value) {
        result[getBrowser().prefix + name] = value;
      });
      return result;
    },

    getAnimation = function (style) {
      var sheet, name, last;

      $.each(cache, function (i, animation) {
        if (style === animation.style) {
          name = animation.name;
          animation.age = 0;
        } else {
          animation.age += 1;
        }
      });

      if (!name) { // Add a new style
        sheet = getStyleSheet();
        name = "jquerypp_animation_" + (animationNum++);

        sheet.insertRule("@" + getBrowser().prefix + "keyframes " + name + ' ' + style, (sheet.cssRules && sheet.cssRules.length) || 0);
        cache.push({
          name: name,
          style: style,
          age: 0
        });

        cache.sort(function (first, second) {
          return first.age - second.age;
        });

        if (cache.length > 20) {
          last = cache.pop();
          removeAnimation(sheet, last.name);
        }
      }

      return name;
    };


  $.fn.animate = function (props, speed, easing, callback) {

    if (passThrough.apply(this, arguments)) {
      return oldanimate.apply(this, arguments);
    }

    var optall = $.speed(speed, easing, callback);

    this.queue(optall.queue, function (done) {
      var

      current,

      properties = [],
        to = "",
        prop, self = $(this),
        duration = optall.duration,

        animationName,

        dataKey,

        style = "{ from {",

        animationEnd = function (currentCSS, exec) {
          self.css(currentCSS);

          self.css(addPrefix({
            "animation-duration": "",
            "animation-name": "",
            "animation-fill-mode": "",
            "animation-play-state": ""
          }));

          if ($.isFunction(optall.old) && exec) {

            optall.old.call(self[0], true)
          }

          $.removeData(self, dataKey, true);
        },
        finishAnimation = function () {

          animationEnd(props, true);
          done();
        };

      for (prop in props) {
        properties.push(prop);
      }

      if (getBrowser().prefix === '-moz-') {

        $.each(properties, function (i, prop) {
          var converter = ffProps[$.camelCase(prop)];
          if (converter && self.css(prop) == 'auto') {
            self.css(prop, converter(self));
          }
        });
      }

      current = self.styles.apply(self, properties);
      $.each(properties, function (i, cur) {

        var name = cur.replace(/([A-Z]|^ms)/g, "-$1").toLowerCase();
        style += name + " : " + cssValue(cur, current[cur]) + "; ";
        to += name + " : " + cssValue(cur, props[cur]) + "; ";
      });

      style += "} to {" + to + " }}";

      animationName = getAnimation(style);
      dataKey = animationName + '.run';

      $._data(this, dataKey, {
        stop: function (gotoEnd) {

          self.css(addPrefix({
            'animation-play-state': 'paused'
          }));

          self.off(getBrowser().transitionEnd, finishAnimation);
          if (!gotoEnd) {

            animationEnd(self.styles.apply(self, properties), false);
          } else {

            animationEnd(props, true);
          }
        }
      });

      self.css(addPrefix({
        "animation-duration": duration + "ms",
        "animation-name": animationName,
        "animation-fill-mode": "forwards"
      }));

      self.one(getBrowser().transitionEnd, finishAnimation);

    });

    return this;
  };

  $.fn.compare = function (element) { //usually
    try {

      element = element.jquery ? element[0] : element;
    } catch (e) {
      return null;
    }

    if (window.HTMLElement) {
      var s = HTMLElement.prototype.toString.call(element)
      if (s == '[xpconnect wrapped native prototype]' || s == '[object XULElement]' || s === '[object Window]') {
        return null;
      }
    }

    if (this[0].compareDocumentPosition) {

      return this[0].compareDocumentPosition(element);
    }

    if (this[0] == document && element != document) return 8;

    var number =

    (this[0] !== element && this[0].contains(element) && 16) +

    (this[0] != element && element.contains(this[0]) && 8),
      docEl = document.documentElement;

    if (this[0].sourceIndex) {

      number += (this[0].sourceIndex < element.sourceIndex && 4)

      number += (this[0].sourceIndex > element.sourceIndex && 2)

      number += (this[0].ownerDocument !== element.ownerDocument || (this[0] != docEl && this[0].sourceIndex <= 0) || (element != docEl && element.sourceIndex <= 0)) && 1
    }

    return number;
  }

  $.toJSON = function (o, replacer, space, recurse) {
    if (typeof(JSON) == 'object' && JSON.stringify) return JSON.stringify(o, replacer, space);

    if (!recurse && $.isFunction(replacer)) o = replacer("", o);

    if (typeof space == "number") space = "          ".substring(0, space);
    space = (typeof space == "string") ? space.substring(0, 10) : "";

    var type = typeof(o);

    if (o === null) return "null";

    if (type == "undefined" || type == "function") return undefined;

    if (type == "number" || type == "boolean") return o + "";

    if (type == "string") return $.quoteString(o);

    if (type == 'object') {
      if (typeof o.toJSON == "function") return $.toJSON(o.toJSON(), replacer, space, true);

      if (o.constructor === Date) {
        var month = o.getUTCMonth() + 1;
        if (month < 10) month = '0' + month;

        var day = o.getUTCDate();
        if (day < 10) day = '0' + day;

        var year = o.getUTCFullYear();

        var hours = o.getUTCHours();
        if (hours < 10) hours = '0' + hours;

        var minutes = o.getUTCMinutes();
        if (minutes < 10) minutes = '0' + minutes;

        var seconds = o.getUTCSeconds();
        if (seconds < 10) seconds = '0' + seconds;

        var milli = o.getUTCMilliseconds();
        if (milli < 100) milli = '0' + milli;
        if (milli < 10) milli = '0' + milli;

        return '"' + year + '-' + month + '-' + day + 'T' + hours + ':' + minutes + ':' + seconds + '.' + milli + 'Z"';
      }

      var process = ($.isFunction(replacer)) ?
      function (k, v) {
        return replacer(k, v);
      } : function (k, v) {
        return v;
      },
        nl = (space) ? "\n" : "",
        sp = (space) ? " " : "";

      if (o.constructor === Array) {
        var ret = [];
        for (var i = 0; i < o.length; i++)
        ret.push(($.toJSON(process(i, o[i]), replacer, space, true) || "null").replace(/^/gm, space));

        return "[" + nl + ret.join("," + nl) + nl + "]";
      }

      var pairs = [],
        proplist;
      if ($.isArray(replacer)) {
        proplist = $.map(replacer, function (v) {
          return (typeof v == "string" || typeof v == "number") ? v + "" : null;
        });
      }
      for (var k in o) {
        var name, val, type = typeof k;

        if (proplist && $.inArray(k + "", proplist) == -1) continue;

        if (type == "number") name = '"' + k + '"';
        else if (type == "string") name = $.quoteString(k);
        else continue; //skip non-string or number keys
        val = $.toJSON(process(k, o[k]), replacer, space, true);

        if (typeof val == "undefined") continue; //skip pairs where the value is a function.
        pairs.push((name + ":" + sp + val).replace(/^/gm, space));
      }

      return "{" + nl + pairs.join("," + nl) + nl + "}";
    }
  };


  $.evalJSON = function (src) {
    if (typeof(JSON) == 'object' && JSON.parse) return JSON.parse(src);
    return eval("(" + src + ")");
  };


  $.secureEvalJSON = function (src) {
    if (typeof(JSON) == 'object' && JSON.parse) return JSON.parse(src);

    var filtered = src;
    filtered = filtered.replace(/\\["\\\/bfnrtu]/g, '@');
    filtered = filtered.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']');
    filtered = filtered.replace(/(?:^|:|,)(?:\s*\[)+/g, '');

    if (/^[\],:{}\s]*$/.test(filtered)) return eval("(" + src + ")");
    else throw new SyntaxError("Error parsing JSON, source is not valid.");
  };


  $.quoteString = function (string) {
    if (string.match(_escapeable)) {
      return '"' + string.replace(_escapeable, function (a) {
        var c = _meta[a];
        if (typeof c === 'string') return c;
        c = a.charCodeAt();
        return '\\u00' + Math.floor(c / 16).toString(16) + (c % 16).toString(16);
      }) + '"';
    }
    return '"' + string + '"';
  };

  var _escapeable = /["\\\x00-\x1f\x7f-\x9f]/g;

  var _meta = {
    '\b': '\\b',
    '\t': '\\t',
    '\n': '\\n',
    '\f': '\\f',
    '\r': '\\r',
    '"': '\\"',
    '\\': '\\\\'
  };

  $.cookie = function (name, value, options) {
    if (typeof value != 'undefined') {

      options = options || {};
      if (value === null) {
        value = '';
        options.expires = -1;
      }

      if (typeof value == 'object' && $.toJSON) {
        value = $.toJSON(value);
      }
      var expires = '';

      if (options.expires && (typeof options.expires == 'number' || options.expires.toUTCString)) {
        var date;
        if (typeof options.expires == 'number') {
          date = new Date();
          date.setTime(date.getTime() + (options.expires * 24 * 60 * 60 * 1000));
        }
        else {
          date = options.expires;
        }
        expires = '; expires=' + date.toUTCString(); // use expires attribute, max-age is not supported by IE
      }

      var path = options.path ? '; path=' + (options.path) : '';
      var domain = options.domain ? '; domain=' + (options.domain) : '';
      var secure = options.secure ? '; secure' : '';

      document.cookie = [name, '=', encodeURIComponent(value), expires, path, domain, secure].join('');
    }
    else { // only name given, get cookie
      var cookieValue = null;
      if (document.cookie && document.cookie != '') {
        var cookies = document.cookie.split(';');
        for (var i = 0; i < cookies.length; i++) {
          var cookie = $.trim(cookies[i]);

          if (cookie.substring(0, name.length + 1) == (name + '=')) {

            cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
            break;
          }
        }
      }

      if ($.evalJSON && cookieValue && cookieValue.match(/^\s*\{/)) {
        try {
          cookieValue = $.evalJSON(cookieValue);
        }
        catch (e) {}
      }
      return cookieValue;
    }
  };

  var

  weird = /button|select/i,
    getBoxes = {},
    checks = {
      width: ["Left", "Right"],
      height: ['Top', 'Bottom'],
      oldOuterHeight: $.fn.outerHeight,
      oldOuterWidth: $.fn.outerWidth,
      oldInnerWidth: $.fn.innerWidth,
      oldInnerHeight: $.fn.innerHeight
    },
    supportsSetter = $.fn.jquery >= '1.8.0';

  $.each({

    width:

    "Width",

    height:

    "Height"
  }, function (lower, Upper) {

    getBoxes[lower] = function (el, boxes) {
      var val = 0;
      if (!weird.test(el.nodeName)) {

        var myChecks = [];
        $.each(checks[lower], function () {
          var direction = this;
          $.each(boxes, function (name, val) {
            if (val) myChecks.push(name + direction + (name == 'border' ? "Width" : ""));
          })
        })
        $.each($.styles(el, myChecks), function (name, value) {
          val += (parseFloat(value) || 0);
        })
      }
      return val;
    }

    if (!supportsSetter) {
      $.fn["outer" + Upper] = function (v, margin) {
        var first = this[0];
        if (typeof v == 'number') {

          first && this[lower](v - getBoxes[lower](first, {
            padding: true,
            border: true,
            margin: margin
          }))
          return this;
        } else {

          return first ? checks["oldOuter" + Upper].apply(this, arguments) : null;
        }
      }
      $.fn["inner" + Upper] = function (v) {
        var first = this[0];
        if (typeof v == 'number') {

          first && this[lower](v - getBoxes[lower](first, {
            padding: true
          }))
          return this;
        } else {

          return first ? checks["oldInner" + Upper].apply(this, arguments) : null;
        }
      }
    }

    var animate = function (boxes) {

      return function (fx) {
        if (fx[supportsSetter ? 'pos' : 'state'] == 0) {
          fx.start = $(fx.elem)[lower]();
          fx.end = fx.end - getBoxes[lower](fx.elem, boxes);
        }
        fx.elem.style[lower] = (fx.pos * (fx.end - fx.start) + fx.start) + "px"
      }
    }
    $.fx.step["outer" + Upper] = animate({
      padding: true,
      border: true
    })
    $.fx.step["outer" + Upper + "Margin"] = animate({
      padding: true,
      border: true,
      margin: true
    })
    $.fx.step["inner" + Upper] = animate({
      padding: true
    })

  })

  var

  keyBreaker = /[^\[\]]+/g,

    convertValue = function (value) {
      if ($.isNumeric(value)) {
        return parseFloat(value);
      } else if (value === 'true') {
        return true;
      } else if (value === 'false') {
        return false;
      } else if (value === '' || value === null) {
        return undefined;
      }
      return value;
    },

    nestData = function (elem, type, data, parts, value, seen, fullName) {
      var name = parts.shift();

      fullName = fullName ? fullName + '.' + name : name;

      if (parts.length) {
        if (!data[name]) {
          data[name] = {};
        }

        nestData(elem, type, data[name], parts, value, seen, fullName);
      } else {

        if (fullName in seen && type != "radio" && !$.isArray(data[name])) {
          if (name in data) {
            data[name] = [data[name]];
          } else {
            data[name] = [];
          }
        } else {
          seen[fullName] = true;
        }

        if ((type == "radio" || type == "checkbox") && !elem.is(":checked")) {
          return
        }

        if (!data[name]) {
          data[name] = value;
        } else {
          data[name].push(value);
        }


      }

    };


  $.fn.extend({
    formParams: function (params) {

      var convert;

      if ( !! params === params) {
        convert = params;
        params = null;
      }

      if (params) {
        return this.setParams(params);
      } else {
        return this.getParams(convert);
      }
    },
    setParams: function (params) {

      this.find("[name]").each(function () {
        var $this = $(this),
          value = params[$this.attr("name")];

        if (value !== undefined) {

          if ($this.is(":radio")) {
            if ($this.val() == value) {
              $this.attr("checked", true);
            }
          } else if ($this.is(":checkbox")) {

            value = $.isArray(value) ? value : [value];
            if ($.inArray($this.val(), value) > -1) {
              $this.attr("checked", true);
            }
          } else {
            $this.val(value);
          }
        }
      });
    },
    getParams: function (convert) {
      var data = {},

        seen = {},
        current;

      this.find("[name]:not(:disabled)").each(function () {
        var $this = $(this),
          type = $this.attr("type"),
          name = $this.attr("name"),
          value = $this.val(),
          parts;

        if (type == "submit" || !name) {
          return;
        }

        parts = name.match(keyBreaker);
        if (!parts.length) {
          parts = [name];
        }

        if (convert) {
          value = convertValue(value);
        }

        nestData($this, type, data, parts, value, seen);

      });

      return data;
    }
  });

  $.fn.range =

  function () {
    return $.Range(this[0])
  }

  var convertType = function (type) {
    return type.replace(/([a-z])([a-z]+)/gi, function (all, first, next) {
      return first + next.toLowerCase()
    }).replace(/_/g, "");
  },

    reverse = function (type) {
      return type.replace(/^([a-z]+)_TO_([a-z]+)/i, function (all, first, last) {
        return last + "_TO_" + first;
      });
    },
    getWindow = function (element) {
      return element ? element.ownerDocument.defaultView || element.ownerDocument.parentWindow : window
    },
    bisect = function (el, start, end) {

      if (end - start == 1) {
        return
      }
    },
    support = {};

  $.Range = function (range) {

    if (this.constructor !== $.Range) {
      return new $.Range(range);
    }

    if (range && range.jquery) {
      range = range[0];
    }

    if (!range || range.nodeType) {

      this.win = getWindow(range)
      if (this.win.document.createRange) {
        this.range = this.win.document.createRange()
      } else if (this.win && this.win.document.body && this.win.document.body.createTextRange) {
        this.range = this.win.document.body.createTextRange()
      }

      if (range) {
        this.select(range)
      }
    }

    else if (range.clientX != null || range.pageX != null || range.left != null) {
      this.moveToPoint(range);
    }

    else if (range.originalEvent && range.originalEvent.touches && range.originalEvent.touches.length) {
      this.moveToPoint(range.originalEvent.touches[0])

    }

    else if (range.originalEvent && range.originalEvent.changedTouches && range.originalEvent.changedTouches.length) {
      this.moveToPoint(range.originalEvent.changedTouches[0])
    }

    else {
      this.range = range;
    }
  };

  $.Range.

  current = function (el) {
    var win = getWindow(el),
      selection;
    if (win.getSelection) {

      selection = win.getSelection()
      return new $.Range(selection.rangeCount ? selection.getRangeAt(0) : win.document.createRange())
    } else {

      return new $.Range(win.document.selection.createRange());
    }
  };

  $.extend($.Range.prototype,

  {

    moveToPoint: function (point) {
      var clientX = point.clientX,
        clientY = point.clientY
        if (!clientX) {
          var off = scrollOffset();
          clientX = (point.pageX || point.left || 0) - off.left;
          clientY = (point.pageY || point.top || 0) - off.top;
        }
        if (support.moveToPoint) {
          this.range = $.Range().range
          this.range.moveToPoint(clientX, clientY);
          return this;
        }

        var parent = document.elementFromPoint(clientX, clientY);

      for (var n = 0; n < parent.childNodes.length; n++) {
        var node = parent.childNodes[n];
        if (node.nodeType === 3 || node.nodeType === 4) {
          var range = $.Range(node),
            length = range.toString().length;

          for (var i = 1; i < length + 1; i++) {
            var rect = range.end(i).rect();
            if (rect.left <= clientX && rect.left + rect.width >= clientX && rect.top <= clientY && rect.top + rect.height >= clientY) {
              range.start(i - 1);
              this.range = range.range;
              return this;
            }
          }
        }
      }

      var previous;
      iterate(parent.childNodes, function (textNode) {
        var range = $.Range(textNode);
        if (range.rect().top > point.clientY) {
          return false;
        } else {
          previous = range;
        }
      });

      if (previous) {
        previous.start(previous.toString().length);
        this.range = previous.range;
      } else {
        this.range = $.Range(parent).range
      }
    },

    window: function () {
      return this.win || window;
    },

    overlaps: function (elRange) {
      if (elRange.nodeType) {
        elRange = $.Range(elRange).select(elRange);
      }

      var startToStart = this.compare("START_TO_START", elRange),
        endToEnd = this.compare("END_TO_END", elRange)

        if (startToStart <= 0 && endToEnd >= 0) {
          return true;
        }

        if (startToStart >= 0 && this.compare("START_TO_END", elRange) <= 0) {
          return true;
        }

        if (this.compare("END_TO_START", elRange) >= 0 && endToEnd <= 0) {
          return true;
        }
        return false;
    },

    collapse: function (toStart) {
      this.range.collapse(toStart === undefined ? true : toStart);
      return this;
    },

    toString: function () {
      return typeof this.range.text == "string" ? this.range.text : this.range.toString();
    },

    start: function (set) {

      if (set === undefined) {
        if (this.range.startContainer) {
          return {
            container: this.range.startContainer,
            offset: this.range.startOffset
          }
        } else {

          var start = this.clone().collapse().parent();

          var startRange = $.Range(start).select(start).collapse();
          startRange.move("END_TO_START", this);
          return {
            container: start,
            offset: startRange.toString().length
          }
        }
      } else {
        if (this.range.setStart) {

          if (typeof set == 'number') {
            this.range.setStart(this.range.startContainer, set)
          } else if (typeof set == 'string') {
            var res = callMove(this.range.startContainer, this.range.startOffset, parseInt(set, 10))
            this.range.setStart(res.node, res.offset);
          } else {
            this.range.setStart(set.container, set.offset)
          }
        } else {
          if (typeof set == "string") {
            this.range.moveStart('character', parseInt(set, 10))
          } else {

            var container = this.start().container,
              offset
              if (typeof set == "number") {
                offset = set
              } else {
                container = set.container
                offset = set.offset
              }
              var newPoint = $.Range(container).collapse();

            newPoint.range.move(offset);
            this.move("START_TO_START", newPoint);
          }
        }
        return this;
      }

    },

    end: function (set) {

      if (set === undefined) {
        if (this.range.startContainer) {
          return {
            container: this.range.endContainer,
            offset: this.range.endOffset
          }
        }
        else {
          var

          end = this.clone().collapse(false).parent(),

            endRange = $.Range(end).select(end).collapse();
          endRange.move("END_TO_END", this);
          return {
            container: end,
            offset: endRange.toString().length
          }
        }
      } else {
        if (this.range.setEnd) {
          if (typeof set == 'number') {
            this.range.setEnd(this.range.endContainer, set)
          } else if (typeof set == 'string') {
            var res = callMove(this.range.endContainer, this.range.endOffset, parseInt(set, 10))
            this.range.setEnd(res.node, res.offset);
          } else {
            this.range.setEnd(set.container, set.offset)
          }
        } else {
          if (typeof set == "string") {
            this.range.moveEnd('character', parseInt(set, 10));
          } else {

            var container = this.end().container,
              offset
              if (typeof set == "number") {
                offset = set
              } else {
                container = set.container
                offset = set.offset
              }
              var newPoint = $.Range(container).collapse();

            newPoint.range.move(offset);
            this.move("END_TO_START", newPoint);
          }
        }
        return this;
      }
    },

    parent: function () {
      if (this.range.commonAncestorContainer) {
        return this.range.commonAncestorContainer;
      } else {

        var parentElement = this.range.parentElement(),
          range = this.range;

        iterate(parentElement.childNodes, function (txtNode) {
          if ($.Range(txtNode).range.inRange(range)) {

            parentElement = txtNode;
            return false;
          }
        });

        return parentElement;
      }
    },

    rect: function (from) {
      var rect = this.range.getBoundingClientRect();

      if (!rect.height && !rect.width) {
        rect = this.range.getClientRects()[0]
      }
      if (from === 'page') {

        var off = scrollOffset();
        rect = $.extend({}, rect);
        rect.top += off.top;
        rect.left += off.left;
      }
      return rect;
    },

    rects: function (from) {

      var rects = $.map($.makeArray(this.range.getClientRects()).sort(function (rect1, rect2) {
        return rect2.width * rect2.height - rect1.width * rect1.height;
      }), function (rect) {
        return $.extend({}, rect)
      }),
        i = 0,
        j, len = rects.length;

      while (i < rects.length) {
        var cur = rects[i],
          found = false;

        j = i + 1;
        while (j < rects.length) {
          if (withinRect(cur, rects[j])) {
            if (!rects[j].width) {
              rects.splice(j, 1)
            } else {
              found = rects[j];
              break;
            }
          } else {
            j++;
          }
        }

        if (found) {
          rects.splice(i, 1)
        } else {
          i++;
        }

      }

      if (from == 'page') {
        var off = scrollOffset();
        return $.each(rects, function (ith, item) {
          item.top += off.top;
          item.left += off.left;
        })
      }

      return rects;
    }

  });
  (function () {

    var fn = $.Range.prototype,
      range = $.Range().range;


    fn.compare = range.compareBoundaryPoints ?
    function (type, range) {
      return this.range.compareBoundaryPoints(this.window().Range[reverse(type)], range.range)
    } : function (type, range) {
      return this.range.compareEndPoints(convertType(type), range.range)
    }


    fn.move = range.setStart ?
    function (type, range) {

      var rangesRange = range.range;
      switch (type) {
      case "START_TO_END":
        this.range.setStart(rangesRange.endContainer, rangesRange.endOffset)
        break;
      case "START_TO_START":
        this.range.setStart(rangesRange.startContainer, rangesRange.startOffset)
        break;
      case "END_TO_END":
        this.range.setEnd(rangesRange.endContainer, rangesRange.endOffset)
        break;
      case "END_TO_START":
        this.range.setEnd(rangesRange.startContainer, rangesRange.startOffset)
        break;
      }

      return this;
    } : function (type, range) {
      this.range.setEndPoint(convertType(type), range.range)
      return this;
    };
    var cloneFunc = range.cloneRange ? "cloneRange" : "duplicate",
      selectFunc = range.selectNodeContents ? "selectNodeContents" : "moveToElementText";

    fn.

    clone = function () {
      return $.Range(this.range[cloneFunc]());
    };

    fn.

    select = range.selectNodeContents ?
    function (el) {
      if (!el) {
        var selection = this.window().getSelection();
        selection.removeAllRanges();
        selection.addRange(this.range);
      } else {
        this.range.selectNodeContents(el);
      }
      return this;
    } : function (el) {
      if (!el) {
        this.range.select()
      } else if (el.nodeType === 3) {

        var parent = el.parentNode,
          start = 0,
          end;
        iterate(parent.childNodes, function (txtNode) {
          if (txtNode === el) {
            end = start + txtNode.nodeValue.length;
            return false;
          } else {
            start = start + txtNode.nodeValue.length
          }
        })
        this.range.moveToElementText(parent);

        this.range.moveEnd('character', end - this.range.text.length)
        this.range.moveStart('character', start);
      } else {
        this.range.moveToElementText(el);
      }
      return this;
    };

  })();

  var iterate = function (elems, cb) {
    var elem, start;
    for (var i = 0; elems[i]; i++) {
      elem = elems[i];