puffer 0.0.23 → 0.0.24

data/app/assets/javascripts/puffer/{right.js → right-src.js}

@@ -1,27 +1,27 @@
 /**
- * RightJS, http://rightjs.org
- * Released under the MIT license
+ * RightJS v2.2.3 - http://rightjs.org
+ * Released under the terms of MIT license
  *
- * Copyright (C) 2008-2010 Nikolay Nemshilov
+ * Copyright (C) 2008-2011 Nikolay Nemshilov
  */
 /**
  * The basic layout for RightJS builds
  *
- * Copyright (C) 2010 Nikolay Nemshilov
+ * Copyright (C) 2008-2011 Nikolay Nemshilov
  */
-var RightJS = (function(window, document, Object, Array, String, Function, Number, Math) {
+var RightJS = (function(window, document, Object, Array, String, Function, Number, Math, undefined) {
 
 /**
  * The framework description object
  *
- * Copyright (C) 2008-2010 Nikolay Nemshilov
+ * Copyright (C) 2008-2011 Nikolay Nemshilov
  */
 var RightJS = function(value) {
   return value; // <- a dummy method to emulate the safe-mode
 };
 
-RightJS.version = "2.2.0";
-RightJS.modules =["core", "dom", "form", "events", "xhr", "fx", "cookie"];
+RightJS.version = "2.2.3";
+RightJS.modules =["core", "dom", "form", "events", "xhr", "fx", "cookie", "olds"];
 
 
 
@@ -187,7 +187,7 @@ isArray = RightJS.isArray = function(value) {
  * @return boolean check result
  */
 isElement = RightJS.isElement = function(value) {
-  return !!(value && value.tagName);
+  return value != null && value.nodeType === 1;
 },
 
 /** !#server
@@ -197,7 +197,7 @@ isElement = RightJS.isElement = function(value) {
  * @return boolean check result
  */
 isNode = RightJS.isNode = function(value) {
-  return !!(value && value.nodeType);
+  return value != null && value.nodeType != null;
 },
 
 /** !#server
@@ -248,23 +248,6 @@ $w = RightJS.$w = function(string) {
   return string.trim().split(/\s+/);
 },
 
-/**
- * converts any iterables into an array
- *
- * @param Object iterable
- * @return Array list
- */
-$A = RightJS.$A = function(it) {
-  try {
-    return slice.call(it);
-  } catch(e) {
-    for (var a=[], i=0, length = it.length; i < length; i++) {
-      a[i] = it[i];
-    }
-    return a;
-  }
-},
-
 /**
  * generates an unique id for an object
  *
@@ -273,42 +256,73 @@ $A = RightJS.$A = function(it) {
  */
 $uid = RightJS.$uid = function(item) {
   return UID_KEY in item ? item[UID_KEY] : (item[UID_KEY] = UID++);
+},
+
+/**
+ * converts any iterables into an array
+ *
+ * @param Object iterable
+ * @return Array list
+ */
+$A = RightJS.$A = function(it) {
+  return slice.call(it, 0);
 };
 
+/** !#server
+ * IE needs a patch for the $A function
+ * because it doesn't handle all the cases
+ */
+if (!A_proto.map) {
+  $A = RightJS.$A = function(it) {
+    try {
+      return slice.call(it, 0);
+    } catch(e) {
+      for (var a=[], i=0, length = it.length; i < length; i++) {
+        a[i] = it[i];
+      }
+      return a;
+    }
+  };
+}
+
 /** !#server
  * Internet Explorer needs some additional mumbo-jumbo in here
  */
 if (isHash(HTML)) {
   isHash = RightJS.isHash = function(value) {
     return to_s.call(value) === '[object Object]' &&
-      value !== null && typeof(value) !== 'undefined' &&
-      typeof(value.hasOwnProperty) !== 'undefined';
+      value != null && value.hasOwnProperty != null;
   };
 }
+
+
 /**
  * Generating methods for native units extending
  */
-var i=0, natives = 'Array Function Number String Date RegExp'.split(' '),
-include_native = function() {
-  for (var i=0; i < arguments.length; i++) {
-    if (isHash(arguments[i])) {
-      $ext(this.prototype,  arguments[i]);
-      $ext(this.Methods, arguments[i]);
-    }
-  }
-};
-
-for (; i < natives.length; i++) {
-  $ext(RightJS[natives[i]] = window[natives[i]], {
+// adds a standard '.include' method to the native unit
+function extend_native(klass) {
+  return $ext(klass, {
     Methods: {},
-    include: include_native
+    include: function() {
+      for (var i=0, l = arguments.length; i < l; i++) {
+        if (isHash(arguments[i])) {
+          $ext(klass.prototype, arguments[i]);
+          $ext(klass.Methods,   arguments[i]);
+        }
+      }
+    }
   });
 }
 
+for (var i=0, natives = 'Array Function Number String Date RegExp'.split(' '); i < natives.length; i++) {
+  RightJS[natives[i]] = extend_native(new Function('return '+ natives[i])());
+}
+
 // referring those two as well
 RightJS.Object = Object;
 RightJS.Math   = Math;
 
+
 /**
  * Checks if the data is an array and if not,
  * then makes an array out of it
@@ -458,7 +472,7 @@ $ext(Object, {
    */
   merge: function() {
     var object = {}, i=0, args=arguments, key;
-    for (; i < args.length; i++) {
+    for (l = args.length; i < l; i++) {
       if (isHash(args[i])) {
         for (key in args[i]) {
           object[key] = isHash(args[i][key]) && !(args[i][key] instanceof Class) ?
@@ -479,7 +493,7 @@ $ext(Object, {
     var tokens = [], key, value, encode = encodeURIComponent;
     for (key in object) {
       value = ensure_array(object[key]);
-      for (var i=0; i < value.length; i++) {
+      for (var i=0, l = value.length; i < l; i++) {
         tokens.push(encode(key) +'='+ encode(value[i]));
       }
     }
@@ -538,13 +552,13 @@ var original_sort = A_proto.sort,
 
 // JavaScript 1.6 methods recatching up or faking
 for_each = A_proto.forEach || function(callback, scope) {
-  for (var i=0; i < this.length; i++) {
+  for (var i=0, l=this.length; i < l; i++) {
     callback.call(scope, this[i], i, this);
   }
 },
 
 filter   = A_proto.filter || function(callback, scope) {
-  for (var result=[], j=0, i=0; i < this.length; i++) {
+  for (var result=[], j=0, i=0, l=this.length; i < l; i++) {
     if (callback.call(scope, this[i], i, this)) {
       result[j++] = this[i];
     }
@@ -553,7 +567,7 @@ filter   = A_proto.filter || function(callback, scope) {
 },
 
 reject   = function(callback, scope) {
-  for (var result=[], j=0, i=0; i < this.length; i++) {
+  for (var result=[], j=0, i=0, l=this.length; i < l; i++) {
     if (!callback.call(scope, this[i], i, this)) {
       result[j++] = this[i];
     }
@@ -562,14 +576,14 @@ reject   = function(callback, scope) {
 },
 
 map      = A_proto.map || function(callback, scope) {
-  for (var result=[], i=0; i < this.length; i++) {
+  for (var result=[], i=0, l=this.length; i < l; i++) {
     result[i] = callback.call(scope, this[i], i, this);
   }
   return result;
 },
 
 some     = A_proto.some || function(callback, scope) {
-  for (var i=0; i < this.length; i++) {
+  for (var i=0, l=this.length; i < l; i++) {
     if (callback.call(scope, this[i], i, this)) {
       return true;
     }
@@ -578,7 +592,7 @@ some     = A_proto.some || function(callback, scope) {
 },
 
 every    = A_proto.every || function(callback, scope) {
-  for (var i=0; i < this.length; i++) {
+  for (var i=0, l=this.length; i < l; i++) {
     if (!callback.call(scope, this[i], i, this)) {
       return false;
     }
@@ -587,7 +601,7 @@ every    = A_proto.every || function(callback, scope) {
 },
 
 first    = function(callback, scope) {
-  for (var i=0; i < this.length; i++) {
+  for (var i=0, l=this.length; i < l; i++) {
     if (callback.call(scope, this[i], i, this)) {
       return this[i];
     }
@@ -629,7 +643,6 @@ function guess_callback(argsi, array) {
 
 // defining the manual break errors class
 function Break() {}
-Break.prototype = Error.prototype;
 
 // calls the given method with preprocessing the arguments
 function call_method(func, scope, args) {
@@ -660,7 +673,7 @@ Array.include({
    * @return Integer index or -1 if not found
    */
   indexOf: A_proto.indexOf || function(value, from) {
-    for (var i=(from<0) ? Math.max(0, this.length+from) : from || 0; i < this.length; i++) {
+    for (var i=(from<0) ? Math.max(0, this.length+from) : from || 0, l=this.length; i < l; i++) {
       if (this[i] === value) {
         return i;
       }
@@ -980,7 +993,7 @@ Array.include({
    * @return Number a summ of values on the list
    */
   sum: function() {
-    for(var sum=0, i=0; i<this.length; sum += this[i++]) {}
+    for(var sum=0, i=0, l=this.length; i < l; sum += this[i++]) {}
     return sum;
   }
 });
@@ -1015,7 +1028,7 @@ String.include({
    * @return boolean check result
    */
   blank: function() {
-    return (/^\s*$/).test(this);
+    return this == false;
   },
 
   /**
@@ -1044,10 +1057,13 @@ String.include({
    * @return String without scripts
    */
   stripScripts: function(option) {
-    var scripts = '', text = this.replace(/<script[^>]*>([\s\S]*?)<\/script>/img, function(match, source) {
-      scripts += source + "\n";
-      return '';
-    });
+    var scripts = '', text = this.replace(
+      /<script[^>]*>([\s\S]*?)<\/script>/img,
+      function(match, source) {
+        scripts += source + "\n";
+        return '';
+      }
+    );
 
     if (option === true) {
       $eval(scripts);
@@ -1158,7 +1174,8 @@ String.include({
    * @return Float or NaN
    */
   toFloat: function(strict) {
-    return parseFloat(strict === true ? this : this.replace(',', '.').replace(/(\d)-(\d)/g, '$1.$2'));
+    return parseFloat(strict === true ? this :
+      this.replace(',', '.').replace(/(\d)-(\d)/, '$1.$2'));
   }
 
 });
@@ -1173,7 +1190,7 @@ String.prototype.include = String.prototype.includes;
  *   Some of the functionality inspired by
  *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
  *
- * Copyright (C) 2008-2010 Nikolay V. Nemshilov
+ * Copyright (C) 2008-2011 Nikolay V. Nemshilov
  */
 Function.include({
   /**
@@ -1187,7 +1204,10 @@ Function.include({
   bind: function() {
     var args = $A(arguments), scope = args.shift(), func = this;
     return function() {
-      return func.apply(scope, (args.length || arguments.length) ? args.concat($A(arguments)) : args);
+      return func.apply(scope,
+        (args.length !== 0 || arguments.length !== 0) ?
+          args.concat($A(arguments)) : args
+      );
     };
   },
 
@@ -1291,7 +1311,7 @@ Function.include({
  *   Some methods inspired by
  *     - Ruby      (http://www.ruby-lang.org) Copyright (C) Yukihiro Matsumoto
  *
- * Copyright (C) 2008-2010 Nikolay V. Nemshilov
+ * Copyright (C) 2008-2011 Nikolay V. Nemshilov
  */
 Number.include({
   /**
@@ -1322,6 +1342,33 @@ Number.include({
     return this;
   },
 
+  /**
+   * Maps a list of numbers from current to given
+   * or map a result of calls of the callback on those numbers
+   *
+   * @param {Number} end number
+   * @param {Function} optional callback
+   * @param {Object} optional callback scope
+   * @return {Array} the result list
+   */
+  to: function(number, callback, scope) {
+    var start = this + 0, end = number, result = [], i=start;
+
+    callback = callback || function(i) { return i; };
+
+    if (end > start) {
+      for (; i <= end; i++) {
+        result.push(callback.call(scope, i));
+      }
+    } else {
+      for (; i >= end; i--) {
+        result.push(callback.call(scope, i));
+      }
+    }
+
+    return result;
+  },
+
   abs: function() {
     return Math.abs(this);
   },
@@ -1476,7 +1523,7 @@ Class_Methods = {
     $A(arguments).filter(isHash).each(function(module) {
       Object.each(Class_clean_module(module, false), function(name, method) {
         // searching for the super-method
-        for (var super_method, i=0; i < klasses.length; i++) {
+        for (var super_method, i=0, l = klasses.length; i < l; i++) {
           if (name in klasses[i].prototype) {
             super_method = klasses[i].prototype[name];
             break;
@@ -1497,7 +1544,9 @@ Class_Methods = {
   }
 },
 
-Class_module_callback_names = $w('selfExtended self_extended selfIncluded self_included extend include');
+Class_module_callback_names = $w(
+  'selfExtended self_extended selfIncluded self_included extend include'
+);
 
 // hooking up the class-methods to the root class
 $ext(Class, Class_Methods);
@@ -1536,7 +1585,7 @@ function Class_findSet(object, property) {
     candidates  = [object, constructor].concat(constructor.ancestors || []),
     i = 0;
 
-  for (; i < candidates.length; i++) {
+  for (l = candidates.length; i < l; i++) {
     if (upcased in candidates[i]) {
       return candidates[i][upcased];
     } else if (property in candidates[i]) {
@@ -1581,7 +1630,9 @@ var Options = RightJS.Options = {
    * @return Object current instance
    */
   setOptions: function(opts) {
-    var options = this.options = $ext($ext({}, Class_findSet(this, 'Options')), opts), match, key;
+    var options = this.options = $ext($ext({},
+      Object.clone(Class_findSet(this, 'Options'))), opts
+    ), match, key;
 
     // hooking up the observer options
     if (isFunction(this.on)) {
@@ -1744,7 +1795,10 @@ Observer_create = Observer.create =  function(object, events) {
  */
 Observer_createShortcuts = Observer.createShortcuts = function(object, names) {
   (names || []).each(function(name) {
-    var method_name = 'on'+name.replace(/(^|_|:)([a-z])/g, function(match, pre, chr) { return chr.toUpperCase(); });
+    var method_name = 'on'+name.replace(/(^|_|:)([a-z])/g,
+      function(match, pre, chr) { return chr.toUpperCase(); }
+    );
+
     if (!(method_name in object)) {
       object[method_name] = function() {
         return this.on.apply(this, [name].concat($A(arguments)));
@@ -1836,9 +1890,20 @@ Browser = RightJS.Browser = {
   MobileSafari: /Apple.*Mobile.*Safari/.test(agent),
   Konqueror:    agent.include('Konqueror'),
 
-  // marker for the browsers which require the olds module
-  OLD:          !document.querySelector
-};
+  // internal marker for the browsers which require the olds module
+  OLD:          !document.querySelector,
+  // internal marker for IE browsers version <= 8
+  IE8L:         false
+},
+
+IE8_OR_LESS = false,
+IE_OPACITY  = !('opacity' in HTML.style) && ('filter' in HTML.style);
+
+try {
+  // checking if that an IE version <= 8
+  document.createElement('<input/>');
+  Browser.OLD = Browser.IE8L = IE8_OR_LESS = true;
+} catch(e) {}
 
 
 /**
@@ -1880,7 +1945,9 @@ function Wrapper_makeKlass() {
    */
   return function(object, options) {
     Class_checkPrebind(this);
-    this.initialize(object, options);
+
+    this.initialize.apply(this, arguments); // <- there might be a different number of args in a subclass
+
     var item = this._, uid = UID_KEY in item ? item[UID_KEY] :
       // NOTE we use positive indexes for dom-elements and negative for everything else
       (item[UID_KEY] = (item.nodeType === 1 ? 1 : -1) * UID++);
@@ -1905,7 +1972,7 @@ function Element_Klass(element, options) {
       uid = UID_KEY in raw ? raw[UID_KEY] : (raw[UID_KEY] = UID++);
 
   if (cast !== undefined) {
-    inst = new cast(raw);
+    inst = new cast(raw, options);
     if ('$listeners' in this) {
       inst.$listeners = this.$listeners;
     }
@@ -1925,11 +1992,12 @@ Wrapper.Cast = function(unit) {
  * Event's own Klass function, we don't need to check
  * nothing in here, don't need to hit the wrappers cache and so one
  *
- * @param raw dom-event or an event-name
+ * @param raw dom-event or a string event-name
  * @param bounding element or an object with options
+ * @return void
  */
 function Event_Klass(event, bound_element) {
-  if (typeof event === 'string') {
+  if (typeof(event) === 'string') {
     event = $ext({type: event}, bound_element);
     this.stopped = event.bubbles === false;
 
@@ -1946,8 +2014,9 @@ function Event_Klass(event, bound_element) {
 
   this.target        = wrap(
     // Webkit throws events on textual nodes as well, gotta fix that
-    'target' in event && 'nodeType' in event.target && event.target.nodeType === 3 ?
-      event.target.parentNode : event.target);
+    event.target != null && 'nodeType' in event.target && event.target.nodeType === 3 ?
+      event.target.parentNode : event.target
+  );
 
   this.currentTarget = wrap(event.currentTarget);
   this.relatedTarget = wrap(event.relatedTarget);
@@ -1955,9 +2024,9 @@ function Event_Klass(event, bound_element) {
   this.pageX         = event.pageX;
   this.pageY         = event.pageY;
 
-  // Converting IE properties into W3C ones
-  if (!('target' in event) && 'srcElement' in event) {
-    this.which = event.button == 2 ? 3 : event.button == 4 ? 2 : 1;
+  // making old IE attrs looks like w3c standards
+  if (IE8_OR_LESS && 'srcElement' in event) {
+    this.which         = event.button === 2 ? 3 : event.button === 4 ? 2 : 1;
 
     this.target        = wrap(event.srcElement) || bound_element;
     this.relatedTarget = this.target._ === event.fromElement ? wrap(event.toElement) : this.target;
@@ -1970,6 +2039,7 @@ function Event_Klass(event, bound_element) {
   }
 }
 
+
 /**
  * Private quick wrapping function, unlike `$`
  * it doesn't search by ID and handle double-wrapps
@@ -1979,7 +2049,7 @@ function Event_Klass(event, bound_element) {
  * @return Wrapper dom-wrapper
  */
 function wrap(object) {
-  if (object !== null && object !== undefined) {
+  if (object != null) {
     var wrapper = UID_KEY in object ? Wrappers_Cache[object[UID_KEY]] : undefined;
 
     if (wrapper !== undefined) {
@@ -2127,8 +2197,12 @@ var Event = RightJS.Event = new Class(Wrapper, {
    * @return RightJS.Event this
    */
   stopPropagation: function() {
-    try {        this._.stopPagination();
-    } catch(e) { this._.cancelBubble = true; }
+    if (this._.stopPropagation) {
+      this._.stopPropagation();
+    } else {
+      this._.cancelBubble = true;
+    }
+
     this.stopped = true;
     return this;
   },
@@ -2139,8 +2213,12 @@ var Event = RightJS.Event = new Class(Wrapper, {
    * @return RightJS.Event this
    */
   preventDefault: function() {
-    try {        this._.preventDefault();
-    } catch(e) { this._.returnValue = false; }
+    if (this._.preventDefault) {
+      this._.preventDefault();
+    } else {
+      this._.returnValue = false;
+    }
+
     return this;
   },
 
@@ -2165,15 +2243,20 @@ var Event = RightJS.Event = new Class(Wrapper, {
   /**
    * Returns the event's offset relative to the target element
    *
-   * @return Object {x: ..., y: ...}
+   * @return Object {x: ..., y: ...} or null
    */
   offset: function() {
-    var element_position = this.target.position();
+    if(this.target instanceof Element) {
+      var element_position = this.target.position();
 
-    return {
-      x: this.pageX - element_position.x,
-      y: this.pageY - element_position.y
-    };
+      return {
+        x: this.pageX - element_position.x,
+        y: this.pageY - element_position.y
+      };
+    }
+
+    // triggered outside browser window (at toolbar etc.)
+    return null;
   },
 
   /**
@@ -2203,10 +2286,11 @@ var Event = RightJS.Event = new Class(Wrapper, {
 
 Event_delegation_shortcuts = [];
 
+
 /**
  * The DOM Element unit handling
  *
- * Copyright (C) 2008-2010 Nikolay Nemshilov
+ * Copyright (C) 2008-2011 Nikolay Nemshilov
  */
 
 var Element = RightJS.Element = new Class(Wrapper, {
@@ -2247,10 +2331,7 @@ make_element = function (tag, options) {
 // it doesn't place the 'checked' property correctly, plus there are some issues
 // with clonned SELECT objects, so we are replaceing the elements maker in here
 //
-try {
-  document.createElement('<input/>'); // <- works for IE < 9 only
-  Browser.OLD = true; // forcing IE8 to load the olds module
-
+if (IE8_OR_LESS) {
   make_element = function(tag, options) {
     if (tag === 'input' && options !== undefined) {
       tag = '<input name="'+ options.name +
@@ -2261,7 +2342,7 @@ try {
 
     return document.createElement(tag);
   };
-} catch (e) {}
+}
 
 /**
  * Basic element's constructor
@@ -2312,7 +2393,11 @@ function Element_initialize(inst, element, options) {
 
 Element.include({
   parent: function(css_rule) {
-    return css_rule ? this.parents(css_rule)[0] : wrap(this._.parentNode || null); // <- IE6 need that || null
+    var parent = this._.parentNode, parent_type = parent && parent.nodeType;
+
+    return css_rule ? this.parents(css_rule)[0] :
+      (parent_type === 1 || parent_type === 9) ? // <- IE6 sometimes has a fragment node in there
+      wrap(parent) : null;
   },
 
   parents: function(css_rule) {
@@ -2338,11 +2423,13 @@ Element.include({
   },
 
   next: function(css_rule) {
-    return this.nextSiblings(css_rule)[0];
+    return !css_rule && this._.nextElementSibling !== undefined ?
+      wrap(this._.nextElementSibling) : this.nextSiblings(css_rule)[0];
   },
 
   prev: function(css_rule) {
-    return this.prevSiblings(css_rule)[0];
+    return !css_rule && this._.previousElementSibling !== undefined ?
+      wrap(this._.previousElementSibling) : this.prevSiblings(css_rule)[0];
   },
 
   /**
@@ -2364,7 +2451,7 @@ Element.include({
    * The content might be one of the following data
    *
    *  o) an element instance
-   *  o) a String, which will be converted into content to insert (all the scripts will be parsed out and executed)
+   *  o) a String (all the scripts will be parsed out and executed)
    *  o) a list of Elements
    *  o) a hash like {position: content}
    *
@@ -2374,7 +2461,7 @@ Element.include({
    */
   insert: function(content, position) {
     var scripts = null, element = this._;
-    position = (position||'bottom').toLowerCase();
+    position = position === undefined ? 'bottom' : position;
 
     if (typeof(content) !== 'object') {
       scripts = content = (''+content);
@@ -2382,11 +2469,12 @@ Element.include({
       content = content._;
     }
 
-    Element_insertions[position](element, content.nodeType ? content :
-      Element_createFragment.call(
-        (position === 'bottom' || position === 'top') ?
-          element : element.parentNode, content
-      )
+    Element_insertions[position](element,
+      content.nodeType === undefined ?
+        Element_createFragment(
+          (position === 'bottom' || position === 'top') ?
+            element : element.parentNode, content
+        ) : content
     );
 
     if (scripts !== null) { scripts.evalScripts(); }
@@ -2463,7 +2551,7 @@ Element.include({
    * @return String text content or Element this
    */
   text: function(text) {
-    return text === undefined ? this._.innerHTML.stripTags() :
+    return text === undefined ? (this._.textContent || this._.innerText) :
       this.update(this.doc()._.createTextNode(text));
   },
 
@@ -2622,28 +2710,30 @@ $alias(Element_wraps, {
 var fragment = document.createDocumentFragment(),
     tmp_cont = document.createElement('DIV');
 
-function Element_createFragment(content) {
+function Element_createFragment(context, content) {
   if (typeof(content) === 'string') {
-    var tag   = this.tagName,
+    var tag   = context.tagName,
         tmp   = tmp_cont,
-        wrap  = Element_wraps[tag] || ['', '', 1],
+        wrap  = tag in Element_wraps ? Element_wraps[tag] : ['', '', 1],
         depth = wrap[2];
 
     tmp.innerHTML = wrap[0] + '<'+ tag + '>' + content + '</'+ tag + '>' + wrap[1];
 
-    while (depth-- > 0) {
+    while (depth-- !== 0) {
       tmp = tmp.firstChild;
     }
 
     content = tmp.childNodes;
-  }
 
-  for (var i=0, length = content.length, node; i < length; i++) {
-    // in case of NodeList unit, the elements will be removed out of the list during the appends
-    // therefore if that's an array we use the 'i' variable, and if it's a collection of nodes
-    // then we always hit the first element of the stack
-    node = content[content.length === length ? i : 0];
-    fragment.appendChild(node instanceof Element ? node._ : node);
+    while (content.length !== 0) {
+      fragment.appendChild(content[0]);
+    }
+
+  } else {
+    for (var i=0, length = content.length, node; i < length; i++) {
+      node = content[content.length === length ? i : 0];
+      fragment.appendChild(node instanceof Element ? node._ : node);
+    }
   }
 
   return fragment;
@@ -2689,12 +2779,8 @@ Element.include({
     for (key in hash) {
       c_key = key.indexOf('-') < 0 ? key : key.camelize();
 
-      if (key === 'opacity') {
-        if (Browser_IE) {
-          element_style.filter = 'alpha(opacity='+ hash[key] * 100 +')';
-        } else {
-          element_style.opacity = hash[key];
-        }
+      if (IE_OPACITY && key === 'opacity') {
+        element_style.filter = 'alpha(opacity='+ hash[key] * 100 +')';
       } else if (key === 'float') {
         c_key = Browser_IE ? 'styleFloat' : 'cssFloat';
       }
@@ -2722,10 +2808,12 @@ Element.include({
    *
    * @return Object/CSSDefinition computed styles
    */
-  computedStyles: function() {
-    var element = this._;
-    //     old IE,                 IE8,                    W3C
-    return element.currentStyle || element.runtimeStyle || element.ownerDocument.defaultView.getComputedStyle(element, null) || {};
+  computedStyles: HTML.currentStyle ? function() {
+    return this._.currentStyle || {};
+  } : HTML.runtimeStyle ? function() {
+    return this._.runtimeStyle || {};
+  } : function() {
+    return this._.ownerDocument.defaultView.getComputedStyle(this._, null);
   },
 
   /**
@@ -2813,28 +2901,28 @@ Element.include({
  * @param String style-key
  * @return String clean style
  */
-function clean_style(style, in_key) {
-  var value, key = in_key.camelize();
-
-  switch (key) {
-    case 'opacity':
-      value = !Browser_IE ? style[key].replace(',', '.') :
-        ((/opacity=(\d+)/i.exec(style.filter || '') || ['', '100'])[1].toInt() / 100)+'';
-      break;
+function clean_style(style, key) {
+  key = key.camelize();
+
+  if (key === 'opacity') {
+    return IE_OPACITY ? (
+      (/opacity=(\d+)/i.exec(style.filter || '') ||
+      ['', '100'])[1].toInt() / 100
+    )+'' :style[key].replace(',', '.');
+  }
 
-    case 'float':
-      key = Browser_IE ? 'styleFloat' : 'cssFloat';
+  if (key === 'float') {
+    key = Browser_IE ? 'styleFloat' : 'cssFloat';
+  }
 
-    default:
-      value = style[key];
+  var value = style[key];
 
-      // Opera returns named colors with quotes
-      if (Browser_Opera && /color/i.test(key) && value) {
-        value = value.replace(/"/g, '');
-      }
+  // Opera returns named colors with quotes
+  if (Browser_Opera && /color/i.test(key) && value) {
+    value = value.replace(/"/g, '');
   }
 
-  return value || null;
+  return value;
 }
 
 
@@ -2950,10 +3038,21 @@ Element.include({
    */
   show: function() {
     if (this.hidden()) {
-      // setting 'block' for the divs and 'inline' for the other elements hidden on the css-level
-      var element = this._, value = element.tagName == 'DIV' ? 'block' : 'inline';
+      var element   = this._, value = this._d, dummy;
+
+      // trying to guess the default 'style.display' for this kind of elements
+      if (!value || value === 'none') {
+        dummy = $E(element.tagName).insertTo(HTML);
+        value = dummy.getStyle('display');
+        dummy.remove();
+      }
 
-      element.style.display = this._d == 'none' ? value : this._d || value;
+      // failsafe in case the user been naughty
+      if (value === 'none') {
+        value = 'block';
+      }
+
+      element.style.display = value;
     }
 
     return this;
@@ -3214,7 +3313,7 @@ Element.include({
           }
         };
 
-        if (Browser_IE) {
+        if (IE8_OR_LESS) {
           hash.t._.attachEvent('on'+hash.n, hash.w);
         } else {
           hash.t._.addEventListener(hash.n, hash.w, false);
@@ -3236,7 +3335,7 @@ Element.include({
    */
   stopObserving: function(event, callback) {
     Observer_stopObserving(this, event, callback, function(hash) {
-      if (Browser_IE) {
+      if (IE8_OR_LESS) {
         hash.t._.detachEvent('on'+ hash.n, hash.w);
       } else {
         hash.t._.removeEventListener(hash.n, hash.w, false);
@@ -3264,13 +3363,15 @@ Element.include({
     event.currentTarget = this;
 
     (this.$listeners || []).each(function(hash) {
-      if (hash.e === event.type && hash.f.apply(this, (hash.r?[]:[event]).concat(hash.a)) === false) {
+      if (hash.e === event.type &&
+        hash.f.apply(this, (hash.r?[]:[event]).concat(hash.a)) === false
+      ) {
         event.stop();
       }
     }, this);
 
     // manually bypassing the event to the parent one if it should bubble
-    if (parent && parent.fire && !(event.bubbles === false || event.stopped)) {
+    if (parent && parent.fire && !event.stopped) {
       parent.fire(event);
     }
 
@@ -3305,7 +3406,8 @@ function Element_add_event_shortcuts(tokens) {
 }
 
 Element_add_event_shortcuts(
-  'click rightclick contextmenu mousedown mouseup mouseover mouseout mousemove keypress keydown keyup'
+  'click rightclick contextmenu mousedown mouseup '+
+  'mouseover mouseout mousemove keypress keydown keyup'
 );
 
 
@@ -3327,7 +3429,10 @@ Element_add_event_shortcuts(
    * @return Element matching node or null
    */
   first: function(css_rule) {
-    return wrap(this._.querySelector(css_rule || '*'));
+    return wrap(
+      css_rule === undefined && this._.firstElementChild !== undefined ?
+      this._.firstElementChild : this._.querySelector(css_rule || '*')
+    );
   },
 
   /**
@@ -3545,7 +3650,9 @@ var Form = RightJS.Form = Element_wrappers.FORM = new Class(Element, {
     this.inputs().each(function(element) {
       input = element._;
       name  = input.name;
-      if (!input.disabled && name && (!['checkbox', 'radio'].include(input.type) || input.checked)) {
+      if (!input.disabled && name && (
+        !['checkbox', 'radio'].include(input.type) || input.checked
+      )) {
         value = element.getValue();
         if (name.endsWith('[]')) {
           value = (values[name] || []).concat([value]);
@@ -3819,7 +3926,7 @@ function focus_boobler(raw_event) {
       target = event.target,
       parent = target.parent && target.parent();
 
-  event.type = (raw_event.type === 'focusin' || raw_event.type === 'focus') ? 'focus' : 'blur';
+  event.type = raw_event.type === 'focusin' || raw_event.type === 'focus' ? 'focus' : 'blur';
 
   if (parent) { parent.fire(event); }
 }
@@ -3830,7 +3937,7 @@ function focus_boobler(raw_event) {
  * manually like they were normal events
  *
  */
-if (Browser_IE) {
+if (IE8_OR_LESS) {
   document.attachEvent('onfocusin',  focus_boobler);
   document.attachEvent('onfocusout', focus_boobler);
 } else {
@@ -3859,6 +3966,7 @@ function mouse_io_fire(raw, element, uid, enter) {
   var event = new Event(raw);
   event.type    = enter === true ? 'mouseenter' : 'mouseleave';
   event.bubbles = false;
+  event.stopped = true;
   event.target  = wrap(element);
 
   // replacing the #find method so that UJS didn't
@@ -3907,7 +4015,7 @@ function mouse_io_handler(e) {
   }
 
   if (from && !passed) {
-    while (from.nodeType === 1 && parents.indexOf(from) === -1) {
+    while (from !== null && from.nodeType === 1 && parents.indexOf(from) === -1) {
       uid = $uid(from);
       if (mouse_io_index[uid] !== undefined) {
         mouse_io_fire(e, from, uid,
@@ -4240,7 +4348,9 @@ $w('Element Input Form').each(function(klass) {
           }
         }
 
-        return null; // don't return the string itself in here, it will screw with data-retrieving calls on empty collections
+        // don't return the string itself in here,
+        // it will screw with data-retrieving calls on empty collections
+        return null;
       };
     }
   });
@@ -4310,6 +4420,11 @@ var Xhr = RightJS.Xhr = new Class(Observer, {
     // copying some options to the instance level attributes
     $ext(this.$super(options), this.options);
 
+    // merging in the global params
+    if (this.params != Xhr.Options.params) {
+      this.params = this.prepareData(Xhr.Options.params, this.params);
+    }
+
     // removing the local spinner if it's the same as the global one
     if (Xhr.Options.spinner && $(this.spinner) === $(Xhr.Options.spinner)) {
       this.spinner = null;
@@ -4357,7 +4472,11 @@ var Xhr = RightJS.Xhr = new Class(Observer, {
    * @return Xhr self
    */
   send: function(params) {
-    var add_params = {}, url = this.url, method = this.method.toLowerCase(), headers = this.headers, key, xhr;
+    var add_params = {},
+        url = this.url,
+        method  = this.method.toLowerCase(),
+        headers = this.headers,
+        key, xhr;
 
     if (method == 'put' || method == 'delete') {
       add_params._method = method;
@@ -4435,12 +4554,10 @@ var Xhr = RightJS.Xhr = new Class(Observer, {
       return new Xhr.JSONP(this);
     } else if (this.form && this.form.first('input[type=file]')) {
       return new Xhr.IFramed(this.form);
+    } else if ('ActiveXObject' in window){
+      return new ActiveXObject('MSXML2.XMLHTTP');
     } else {
-      try {
-        return new XMLHttpRequest();
-      } catch(e) {
-        return new ActiveXObject('MSXML2.XMLHTTP');
-      }
+      return new XMLHttpRequest();
     }
   },
 
@@ -4493,20 +4610,17 @@ var Xhr = RightJS.Xhr = new Class(Observer, {
 
   // sanitizes the json-response texts
   sanitizedJSON: function() {
-    try {
-      return JSON.parse(this.text);
-    } catch(e) {
-      // manual json consistancy check
-      if (window.JSON || !(/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(this.text.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, ''))) {
-        if (this.secureJSON) {
-          throw "JSON error: "+this.text;
-        }
-        return null;
+    if (!(/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(
+      this.text.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '')
+    )) {
+      if (this.secureJSON) {
+        throw "JSON error: "+this.text;
       }
+      return null;
     }
 
-    // the fallback JSON extraction
-    return eval("("+this.text+")");
+    return 'JSON' in window ? JSON.parse(this.text) :
+      (new Function("return "+this.text))();
   },
 
   // initializes the request callbacks
@@ -4578,19 +4692,6 @@ $ext(Observer_create(Xhr), {
  *
  * Copyright (C) 2009-2011 Nikolay V. Nemshilov
  */
-
-/**
- * Catches the form submit events and sends the form remotely
- *
- * @param Event submit
- * @param Object xhr options
- * @return void
- */
-function remote_send(event, options) {
-  event.stop();
-  this.send($ext({spinner: this.first('.spinner')}, options));
-}
-
 Form.include({
   /**
    * sends the form via xhr request
@@ -4602,13 +4703,31 @@ Form.include({
     options = options || {};
     options.method = options.method || this._.method || 'post';
 
-    new Xhr(this._.action || document.location.href, options)
-      .onComplete(this.enable.bind(this)).send(this);
+    this.xhr = new Xhr(
+      this._.action || document.location.href,
+      $ext({spinner: this.first('.spinner')}, options)
+    )
+    .onComplete(this.enable.bind(this))
+    .onCancel(this.enable.bind(this))
+    .send(this);
 
     this.disable.bind(this).delay(1); // webkit needs this async call with iframed calls
     return this;
   },
 
+  /**
+   * Cancels current Xhr request (if there are any)
+   *
+   * @return Form this
+   */
+  cancelXhr: function() {
+    if (this.xhr instanceof Xhr) {
+      this.xhr.cancel();
+    }
+
+    return this;
+  },
+
   /**
    * makes the form be remote by default
    *
@@ -4616,10 +4735,11 @@ Form.include({
    * @return Form this
    */
   remotize: function(options) {
-    if (!this.observes('submit', remote_send)) {
-      this.on('submit', remote_send, options);
+    if (!this.remote) {
+      this.on('submit', Form_remote_send, options);
       this.remote = true;
     }
+
     return this;
   },
 
@@ -4629,13 +4749,24 @@ Form.include({
    * @return Form this
    */
   unremotize: function() {
-    this.stopObserving('submit', remote_send);
+    this.stopObserving('submit', Form_remote_send);
     this.remote = false;
-
     return this;
   }
 });
 
+/**
+ * Catches the form submit events and sends the form remotely
+ *
+ * @param Event submit
+ * @param Object xhr options
+ * @return void
+ */
+function Form_remote_send(event, options) {
+  event.stop();
+  this.send(options);
+}
+
 
 /**
  * this module contains the Element unit XHR related extensions
@@ -4669,7 +4800,6 @@ Element.include({
  */
 Xhr.Dummy = {
   open:               function() {},
-  abort:              function() {},
   setRequestHeader:   function() {},
   onreadystatechange: function() {}
 };
@@ -4679,7 +4809,7 @@ Xhr.Dummy = {
  * This unit presents a fake drop in replacement for the XmlHTTPRequest unit
  * but works with an iframe targeting in the background
  *
- * Copyright (C) 2008-2010 Nikolay Nemshilov
+ * Copyright (C) 2008-2011 Nikolay Nemshilov
  */
 Xhr.IFramed = new Class({
   include: Xhr.Dummy,
@@ -4694,7 +4824,7 @@ Xhr.IFramed = new Class({
     this.form = form;
     this.id   = 'xhr_'+ new Date().getTime();
 
-    form.insert('<i><iframe name="'+this.id+'" id="'+this.id+
+    this.form.doc().first('body').append('<i><iframe name="'+this.id+'" id="'+this.id+
       '" width="0" height="0" frameborder="0" src="about:blank"></iframe></i>',
       'after');
 
@@ -4708,7 +4838,7 @@ Xhr.IFramed = new Class({
   onLoad: function() {
     this.status       = 200;
     this.readyState   = 4;
-    
+
     this.form.set('target', '');
 
     try {
@@ -4716,6 +4846,10 @@ Xhr.IFramed = new Class({
     } catch(e) { }
 
     this.onreadystatechange();
+  },
+
+  abort: function() {
+    $(this.id).set('src', 'about:blank');
   }
 });
 
@@ -4723,7 +4857,7 @@ Xhr.IFramed = new Class({
 /**
  * The JSONP Xhr request tonnel
  *
- * Copyright (C) 2010 Nikolay Nemshilov
+ * Copyright (C) 2010-2011 Nikolay Nemshilov
  */
 Xhr.JSONP = new Class({
   include: Xhr.Dummy,
@@ -4787,6 +4921,16 @@ Xhr.JSONP = new Class({
     this.xhr.json = this.xhr.responseJSON = data;
 
     this.onreadystatechange();
+  },
+
+  /**
+   * We can't really cancel a JSONP request
+   * but we can prevent the default handler to ckick in
+   *
+   * @return void
+   */
+  abort: function() {
+    window[this.name] = function() {};
   }
 });
 
@@ -4813,7 +4957,7 @@ var Fx = RightJS.Fx = new Class(Observer, {
 
     // default options
     Options: {
-      fps:        Browser_IE ? 40 : 60,
+      fps:        IE8_OR_LESS ? 40 : 60,
       duration:   'normal',
       transition: 'Sin',
       queue:      true
@@ -5387,7 +5531,7 @@ function style_keys(style) {
       add_variants(keys, key, directions);
     } else if (key.startsWith('background')) {
       add_variants(keys, 'background', ['Color', 'Position', 'PositionX', 'PositionY']);
-    } else if (key === 'opacity' && Browser_IE) {
+    } else if (key === 'opacity' && IE_OPACITY) {
       keys.push('filter');
     } else {
       keys.push(key);
@@ -5459,7 +5603,7 @@ function clean_styles(element, before, after) {
   }
 
   // IE opacity filter fix
-  if (after.filter && !before.filter) {
+  if (IE_OPACITY && after.filter && !before.filter) {
     before.filter = 'alpha(opacity=100)';
   }
 
@@ -5496,15 +5640,18 @@ function clean_styles(element, before, after) {
 
 // cloning the element current styles hash
 function clone_style(element, keys) {
-  for (var i=0, len = keys.length, style = element.computedStyles(), clean = {}, key; i < len; i++) {
+  var i=0, len = keys.length, style = element.computedStyles(), clean = {}, key;
+
+  for (; i < len; i++) {
     key = keys[i];
+
     if (key in style) {
       clean[key] = ''+ style[key];
-    }
 
-    // libwebkit bug fix for in case of languages pack applied
-    if (key === 'opacity') {
-      clean[key] = clean[key].replace(',', '.');
+      // libwebkit bug fix for in case of languages pack applied
+      if (key === 'opacity') {
+        clean[key] = clean[key].replace(',', '.');
+      }
     }
   }
 
@@ -5753,7 +5900,7 @@ Fx.Scroll = new Class(Fx.Attr, {
     this.$super(
       element instanceof Window ?
         element._.document[
-          Browser.WebKit ? 'body' : 'documentElement'
+          'body' in element._.document ? 'body' : 'documentElement'
         ] : element,
       options
     );
@@ -5847,8 +5994,10 @@ var Cookie = RightJS.Cookie = new Class({
    * @return mixed saved value or null if nothing found
    */
   get: function() {
-    var value = this.options.document.cookie.match('(?:^|;)\\s*' + RegExp.escape(this.name) + '=([^;]*)');
-    return (value) ? decodeURIComponent(value[1]) : null;
+    var value = this.options.document.cookie.match(
+      '(?:^|;)\\s*' + RegExp.escape(this.name) + '=([^;]*)'
+    );
+    return value ? decodeURIComponent(value[1]) : null;
   },
 
   /**
@@ -5863,30 +6012,651 @@ var Cookie = RightJS.Cookie = new Class({
 });
 
 
-// globalizing the top-level variables
-$ext(window, Object.without(RightJS, 'version', 'modules'));
+/**
+ * Old IE browser hacks
+ *
+ *   Keep them in one place so they were more compact
+ *
+ * Copyright (C) 2009-2011 Nikolay Nemshilov
+ */
+if (RightJS.Browser.OLD && RightJS.Browser.IE) {
+  // loads DOM element extensions for selected elements
+  window.$ = RightJS.$ = (function(old_function) {
+    return function(id) {
+      var element = old_function(id);
+
+      // old IE browses match both, ID and NAME
+      if (element && element instanceof RightJS.Element &&
+        RightJS.isString(id) && element._.id !== id
+      ) {
+        element = RightJS.$(document).first('#'+ id);
+      }
+
+      return element;
+    };
+  })(RightJS.$);
+}
+
+
+/**
+ * Making the 'submit' and 'change' events bubble under IE browsers
+ *
+ * Copyright (C) 2010-2011 Nikolay Nemshilov
+ */
+
+/**
+ * Tests if there is the event support
+ *
+ * @param String event name
+ * @retrun Boolean check result
+ */
+function event_support_for(name, tag) {
+  var e = document.createElement(tag);
+  e.setAttribute(name, ';');
+  return isFunction(e[name]);
+}
+
+if (!event_support_for('onsubmit', 'form')) {
+  /**
+   * Emulates the 'submit' event bubbling for IE browsers
+   *
+   * @param raw dom-event
+   * @return void
+   */
+  var submit_boobler = function(raw_event) {
+    var event = $(raw_event), element = event.target._,
+        type = element.type, form = element.form, parent;
+
+    if (form && (parent = $(form).parent()) && (
+      (raw_event.keyCode === 13   && (type === 'text'   || type === 'password')) ||
+      (raw_event.type === 'click' && (type === 'submit' || type === 'image'))
+    )) {
+      event.type   = 'submit';
+      event.target = $(form);
+      parent.fire(event);
+    }
+  };
+
+  document.attachEvent('onclick',    submit_boobler);
+  document.attachEvent('onkeypress', submit_boobler);
+}
+
+if (!event_support_for('onchange', 'input')) {
+
+  var get_input_value = function(target) {
+    var element = target._,
+        type    = element.type;
+
+    return type === 'radio' || type === 'checkbox' ?
+      element.checked : target.getValue();
+  },
+
+  /**
+   * Emulates the 'change' event bubbling
+   *
+   * @param Event wrapped dom-event
+   * @param Input wrapped input element
+   * @return void
+   */
+  change_boobler = function(event, target) {
+    var parent  = target.parent(),
+        value   = get_input_value(target);
+
+    if (parent && ''+target._prev_value !== ''+value) {
+      target._prev_value = value; // saving the value so it didn't fire up again
+      event.type = 'change';
+      parent.fire(event);
+    }
+  },
+
+  /**
+   * Catches the input field changes
+   *
+   * @param raw dom-event
+   * @return void
+   */
+  catch_inputs_access = function(raw_event) {
+    var event  = $(raw_event),
+        target = event.target,
+        type   = target._.type,
+        tag    = target._.tagName,
+        input_is_radio = (type === 'radio' || type === 'checkbox');
+
+    if (
+      (event.type === 'click' && (input_is_radio || tag === 'SELECT')) ||
+      (event.type === 'keydown' && (
+        (event.keyCode == 13 && (tag !== 'TEXTAREA')) ||
+        type === 'select-multiple'
+      ))
+    ) {
+      change_boobler(event, target);
+    }
+  },
+
+  /**
+   * Catch inputs blur
+   *
+   * @param raw dom-event
+   * @return void
+   */
+  catch_input_left = function(raw_event) {
+    var event  = $(raw_event),
+        target = event.target;
+
+    if (target instanceof Input) {
+      change_boobler(event, target);
+    }
+  };
+
+  document.attachEvent('onclick',    catch_inputs_access);
+  document.attachEvent('onkeydown',  catch_inputs_access);
+  document.attachEvent('onfocusout', catch_input_left);
+
+  /**
+   * storing the input element previous value, so we could figure out
+   * if it was changed later on
+   */
+  document.attachEvent('onbeforeactivate', function(event) {
+    var element = $(event).target;
+
+    if (element instanceof Input) {
+      element._prev_value = get_input_value(element);
+    }
+  });
+}
+
+
+/**
+ * Konqueror browser fixes
+ *
+ * Copyright (C) 2009-2011 Nikolay V. Nemshilov
+ */
+
+/**
+ * manual position calculator, it works for Konqueror and also
+ * for old versions of Opera and FF
+ */
+if (!RightJS.$E('p')._.getBoundingClientRect) {
+  RightJS.Element.include({
+    position: function() {
+      var element  = this._,
+          top      = element.offsetTop,
+          left     = element.offsetLeft,
+          parent   = element.offsetParent;
+
+      while (parent) {
+        top  += parent.offsetTop;
+        left += parent.offsetLeft;
+
+        parent = parent.offsetParent;
+      }
+
+      return {x: left, y: top};
+    }
+  });
+}
+
 
-return RightJS;
-})(window, document, Object, Array, String, Function, Number, Math);
 /**
- * The old browsers support patch loading script
- * will be included in the core file when it's built
- * with the no-olds option
+ * The manual css-selector feature implementation
  *
- * Basically it just checks all the script tags on the page
- * finds the core inclusion tag and uses it's src attribute
- * to dynamically load the olds patch
+ * Credits:
+ *   - Sizzle    (http://sizzlejs.org)      Copyright (C) John Resig
+ *   - MooTools  (http://mootools.net)      Copyright (C) Valerio Proietti
  *
  * Copyright (C) 2009-2011 Nikolay V. Nemshilov
  */
-if (RightJS.Browser.OLD) {
-  (function(d) {
-    var script  = d.createElement('script'),
-        scripts = d.getElementsByTagName('script'),
-        rjs_spt = scripts[scripts.length - 1];
+var has_native_css_selector = !!document.querySelector,
+    needs_css_engine_patch  = !has_native_css_selector;
+
+if (RightJS.Browser.IE8L) {
+  needs_css_engine_patch = true;
+}
 
-    script.src = rjs_spt.src.replace(/(^|\/)(right)([^\/]+)$/, '$1$2-olds$3');
+if (needs_css_engine_patch) {
+  /**
+   * The token searchers collection
+   */
+  var search = {
+    // search for any descendant nodes
+    ' ': function(element, tag) {
+      return RightJS.$A(element.getElementsByTagName(tag));
+    },
+
+    // search for immidate descendant nodes
+    '>': function(element, tag) {
+      var result = [], node = element.firstChild;
+      while (node) {
+        if (tag === '*' || node.tagName === tag) {
+          result.push(node);
+        }
+        node = node.nextSibling;
+      }
+      return result;
+    },
+
+    // search for immiate sibling nodes
+    '+': function(element, tag) {
+      while ((element = element.nextSibling)) {
+        if (element.tagName) {
+          return (tag === '*' || element.tagName === tag) ? [element] : [];
+        }
+      }
+      return [];
+    },
+
+    // search for late sibling nodes
+    '~': function(element, tag) {
+      var result = [];
+      while ((element = element.nextSibling)) {
+        if (tag === '*' || element.tagName === tag) {
+          result.push(element);
+        }
+      }
+      return result;
+    }
+  },
+
+
+  /**
+   * Collection of pseudo selector matchers
+   */
+  pseudos = {
+    not: function(node, css_rule) {
+      return node.nodeType === 1 && !RightJS.$(node).match(css_rule);
+    },
+
+    checked: function(node) {
+      return node.checked === true;
+    },
+
+    enabled: function(node) {
+      return node.disabled === false;
+    },
+
+    disabled: function(node) {
+      return node.disabled === true;
+    },
+
+    selected: function(node) {
+      return node.selected === true;
+    },
+
+    empty: function(node) {
+      return !node.firstChild;
+    },
+
+    'first-child': function(node, node_name) {
+      while ((node = node.previousSibling)) {
+        if (node.nodeType === 1 && (node_name === null || node.nodeName === node_name)) {
+          return false;
+        }
+      }
+      return true;
+    },
+
+    'first-of-type': function(node) {
+      return pseudos['first-child'](node, node.nodeName);
+    },
+
+    'last-child': function(node, node_name) {
+      while ((node = node.nextSibling)) {
+        if (node.nodeType === 1 && (node_name === null || node.nodeName === node_name)) {
+          return false;
+        }
+      }
+      return true;
+    },
+
+    'last-of-type': function(node) {
+      return pseudos['last-child'](node, node.nodeName);
+    },
+
+    'only-child': function(node, node_name) {
+      return pseudos['first-child'](node, node_name) &&
+        pseudos['last-child'](node, node_name);
+    },
+
+    'only-of-type': function(node) {
+      return pseudos['only-child'](node, node.nodeName);
+    },
+
+    'nth-child': function(node, number, node_name, reverse) {
+      var index = 1, a = number[0], b = number[1];
+
+      while ((node = (reverse === true) ? node.nextSibling : node.previousSibling)) {
+        if (node.nodeType === 1 && (node_name === undefined || node.nodeName === node_name)) {
+          index++;
+        }
+      }
+
+      return (b === undefined ? (index === a) : ((index - b) % a === 0 && (index - b) / a >= 0));
+    },
+
+    'nth-of-type': function(node, number) {
+      return pseudos['nth-child'](node, number, node.nodeName);
+    },
+
+    'nth-last-child': function(node, number) {
+      return pseudos['nth-child'](node, number, undefined, true);
+    },
 
-    rjs_spt.parentNode.appendChild(script);
-  })(document);
+    'nth-last-of-type': function(node, number) {
+      return pseudos['nth-child'](node, number, node.nodeName, true);
+    }
+  },
+
+  // the regexps collection
+  chunker   = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?/g,
+  id_re     = /#([\w\-_]+)/,
+  tag_re    = /^[\w\*]+/,
+  class_re  = /\.([\w\-\._]+)/,
+  pseudo_re = /:([\w\-]+)(\((.+?)\))*$/,
+  attrs_re  = /\[((?:[\w\-]*:)?[\w\-]+)\s*(?:([!\^$*~|]?=)\s*((['"])([^\4]*?)\4|([^'"][^\]]*?)))?\]/,
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+  /**
+   * Builds an atom matcher
+   *
+   * @param String atom definition
+   * @return Object atom matcher
+   */
+  atoms_cache = {},
+  build_atom = function(in_atom) {
+    if (!atoms_cache[in_atom]) {
+      var id, tag, classes, classes_length, attrs, pseudo,
+        values_of_pseudo, match, func, desc = {}, atom = in_atom;
+
+      // grabbing the attributes
+      while((match = atom.match(attrs_re))) {
+        attrs = attrs || {};
+        attrs[match[1]] = { o: match[2] || '', v: match[5] || match[6] || '' };
+        atom = atom.replace(match[0], '');
+      }
+
+      // extracting the pseudos
+      if ((match = atom.match(pseudo_re))) {
+        pseudo = match[1];
+        values_of_pseudo = match[3] === '' ? null : match[3];
+
+        if (pseudo.startsWith('nth')) {
+          // preparsing the nth-child pseoudo numbers
+          values_of_pseudo = values_of_pseudo.toLowerCase();
+
+          if (values_of_pseudo === 'n') {
+            // no need in the pseudo then
+            pseudo = null;
+            values_of_pseudo = null;
+          } else {
+            if (values_of_pseudo === 'odd')  { values_of_pseudo = '2n+1'; }
+            if (values_of_pseudo === 'even') { values_of_pseudo = '2n';   }
+
+            var m = /^([+\-]?\d*)?n([+\-]?\d*)?$/.exec(values_of_pseudo);
+            if (m) {
+              values_of_pseudo = [
+                m[1] === '-' ? -1 : parseInt(m[1], 10) || 1,
+                parseInt(m[2], 10) || 0
+              ];
+            } else {
+              values_of_pseudo = [parseInt(values_of_pseudo, 10), undefined];
+            }
+          }
+        }
+
+        atom = atom.replace(match[0], '');
+      }
+
+      // getting all the other options
+      id      = (atom.match(id_re)    || [1, null])[1];
+      tag     = (atom.match(tag_re)   || '*').toString().toUpperCase();
+      classes = (atom.match(class_re) || [1, ''])[1].split('.').without('');
+      classes_length = classes.length;
+
+      desc.tag = tag;
+
+      if (id || classes.length || attrs || pseudo) {
+        // optimizing a bit the values for quiker runtime checks
+        id      = id     || false;
+        attrs   = attrs  || false;
+        pseudo  = pseudo in pseudos ? pseudos[pseudo] : false;
+        classes = classes_length ? classes : false;
+
+        desc.filter = function(elements) {
+          var node, result = [], i=0, j=0, l = elements.length, failed;
+          for (; i < l; i++) {
+            node   = elements[i];
+
+            //////////////////////////////////////////////
+            // ID check
+            //
+            if (id !== false && node.id !== id) {
+              continue;
+            }
+
+            //////////////////////////////////////////////
+            // Class names check
+            if (classes !== false) {
+              var names = node.className.split(' '),
+                  names_length = names.length,
+                  x = 0; failed = false;
+
+              for (; x < classes_length; x++) {
+                for (var y=0, found = false; y < names_length; y++) {
+                  if (classes[x] === names[y]) {
+                    found = true;
+                    break;
+                  }
+                }
+
+                if (!found) {
+                  failed = true;
+                  break;
+                }
+              }
+
+              if (failed) { continue; }
+            }
+
+            ///////////////////////////////////////////////
+            // Attributes check
+            if (attrs !== false) {
+              var key, attr, operand, value; failed = false;
+              for (key in attrs) {
+                attr = key === 'class' ? node.className : (node.getAttribute(key) || '');
+                operand = attrs[key].o;
+                value   = attrs[key].v;
+
+                if (
+                  (operand === ''   && (key === 'class'|| key === 'lang' ?
+                    (attr === '') : (node.getAttributeNode(key) === null))) ||
+                  (operand === '='  && attr !== value) ||
+                  (operand === '*=' && attr.indexOf(value) === -1) ||
+                  (operand === '^=' && attr.indexOf(value) !== 0)  ||
+                  (operand === '$=' && attr.substring(attr.length - value.length) !== value) ||
+                  (operand === '~=' && attr.split(' ').indexOf(value) === -1) ||
+                  (operand === '|=' && attr.split('-').indexOf(value) === -1)
+                ) { failed = true; break; }
+              }
+
+              if (failed) { continue; }
+            }
+
+            ///////////////////////////////////////////////
+            // Pseudo selectors check
+            if (pseudo !== false) {
+              if (!pseudo(node, values_of_pseudo)) {
+                continue;
+              }
+            }
+
+            result[j++] = node;
+          }
+          return result;
+        };
+      }
+
+      atoms_cache[in_atom] = desc;
+    }
+
+    return atoms_cache[in_atom];
+  },
+
+  /**
+   * Builds a single selector out of a simple rule chunk
+   *
+   * @param Array of a single rule tokens
+   * @return Function selector
+   */
+  tokens_cache = {},
+  build_selector = function(rule) {
+    var rule_key = rule.join('');
+    if (!tokens_cache[rule_key]) {
+      for (var i=0; i < rule.length; i++) {
+        rule[i][1] = build_atom(rule[i][1]);
+      }
+
+      // creates a list of uniq nodes
+      var _uid = RightJS.$uid;
+      var uniq = function(elements) {
+        var uniq = [], uids = [], uid;
+        for (var i=0, length = elements.length; i < length; i++) {
+          uid = _uid(elements[i]);
+          if (!uids[uid]) {
+            uniq.push(elements[i]);
+            uids[uid] = true;
+          }
+        }
+
+        return uniq;
+      };
+
+      // performs the actual search of subnodes
+      var find_subnodes = function(element, atom) {
+        var result = search[atom[0]](element, atom[1].tag);
+        return atom[1].filter ? atom[1].filter(result) : result;
+      };
+
+      // building the actual selector function
+      tokens_cache[rule_key] = function(element) {
+        var founds, sub_founds;
+
+        for (var i=0, i_length = rule.length; i < i_length; i++) {
+          if (i === 0) {
+            founds = find_subnodes(element, rule[i]);
+
+          } else {
+            if (i > 1) { founds = uniq(founds); }
+
+            for (var j=0; j < founds.length; j++) {
+              sub_founds = find_subnodes(founds[j], rule[i]);
+
+              sub_founds.unshift(1); // <- nuke the parent node out of the list
+              sub_founds.unshift(j); // <- position to insert the subresult
+
+              founds.splice.apply(founds, sub_founds);
+
+              j += sub_founds.length - 3;
+            }
+          }
+        }
+
+        return rule.length > 1 ? uniq(founds) : founds;
+      };
+    }
+    return tokens_cache[rule_key];
+  },
+
+
+  /**
+   * Builds the list of selectors for the css_rule
+   *
+   * @param String raw css-rule
+   * @return Array of selectors
+   */
+  selectors_cache = {}, chunks_cache = {},
+  split_rule_to_selectors = function(css_rule) {
+    if (!selectors_cache[css_rule]) {
+      chunker.lastIndex = 0;
+
+      var rules = [], rule = [], rel = ' ', m, token;
+      while ((m = chunker.exec(css_rule))) {
+        token = m[1];
+
+        if (token === '+' || token === '>' || token === '~') {
+          rel = token;
+        } else {
+          rule.push([rel, token]);
+          rel = ' ';
+        }
+
+        if (m[2]) {
+          rules.push(build_selector(rule));
+          rule = [];
+        }
+      }
+      rules.push(build_selector(rule));
+
+      selectors_cache[css_rule] = rules;
+    }
+    return selectors_cache[css_rule];
+  },
+
+
+  /**
+   * The top level method, it just goes throught the css-rule chunks
+   * collect and merge the results that's it
+   *
+   * @param Element context
+   * @param String raw css-rule
+   * @return Array search result
+   */
+  select_all = function(element, css_rule) {
+    var selectors = split_rule_to_selectors(css_rule), result = [];
+    for (var i=0, length = selectors.length; i < length; i++) {
+      result = result.concat(selectors[i](element));
+    }
+
+    return result;
+  },
+
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+  // the previous dom-selection methods replacement
+  dom_extension = {
+    first: function(css_rule) {
+      return this.find(css_rule)[0];
+    },
+
+    find: function(css_rule, raw) {
+      var result, rule = css_rule || '*', element = this._, tag = element.tagName;
+
+      if (has_native_css_selector) {
+        try { // trying to reuse native css-engine under IE8
+          result = $A(element.querySelectorAll(rule));
+        } catch(e) { // if it fails use our own engine
+          result = select_all(element, rule);
+        }
+      } else {
+        result = select_all(element, rule);
+      }
+
+      return raw === true ? result : result.map(RightJS.$);
+    }
+  };
+
+  // hooking up the rightjs wrappers with the new methods
+  RightJS.$ext(RightJS.Element.prototype, dom_extension);
+  RightJS.$ext(RightJS.Document.prototype, dom_extension);
 }
+
+// globalizing the top-level variables
+$ext(window, Object.without(RightJS, 'version', 'modules'));
+
+return RightJS;
+})(window, document, Object, Array, String, Function, Number, Math);