right-rails 1.0.10 → 1.0.12

data/public/javascripts/right-olds-src.js

@@ -1,26 +1,29 @@
 /**
- * This is old browsers support patch for RightJS
+ * The old browsers support module for RightJS
  *
- * The library released under terms of the MIT license
+ * Released under the terms of the MIT license
  * Visit http://rightjs.org for more details
  *
- * Copyright (C) 2008-2010 Nikolay V. Nemshilov
+ * Copyright (C) 2008-2011 Nikolay V. Nemshilov
  */
+(function(RightJS) {
 /**
  * Old IE browser hacks
  *
  *   Keep them in one place so they were more compact
  *
- * Copyright (C) 2009-2010 Nikolay Nemshilov
+ * Copyright (C) 2009-2011 Nikolay Nemshilov
  */
-if (RightJS.Browser.OLD) {
+if (RightJS.Browser.OLD && RightJS.Browser.IE) {
   // loads DOM element extensions for selected elements
-  $ = RightJS.$ = (function(old_function) {
+  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) {
+      if (element && element instanceof RightJS.Element &&
+        RightJS.isString(id) && element._.id !== id
+      ) {
         element = RightJS.$(document).first('#'+ id);
       }
 
@@ -30,17 +33,145 @@ if (RightJS.Browser.OLD) {
 }
 
 
+/**
+ * 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-2010 Nikolay V. Nemshilov
+ * 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) {
+if (!RightJS.$E('p')._.getBoundingClientRect) {
   RightJS.Element.include({
     position: function() {
       var element  = this._,
@@ -68,412 +199,454 @@ if (!RightJS.$E('p').getBoundingClientRect) {
  *   - Sizzle    (http://sizzlejs.org)      Copyright (C) John Resig
  *   - MooTools  (http://mootools.net)      Copyright (C) Valerio Proietti
  *
- * Copyright (C) 2009-2010 Nikolay V. Nemshilov
+ * Copyright (C) 2009-2011 Nikolay V. Nemshilov
  */
-if (!document.querySelector) {
-  (function(RightJS) {
-    /**
-     * 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;
+var has_native_css_selector = !!document.querySelector,
+    needs_css_engine_patch  = !has_native_css_selector;
+
+if (RightJS.Browser.IE8L) {
+  needs_css_engine_patch = true;
+}
+
+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);
         }
-        return result;
-      },
-
-      // search for immiate sibling nodes
-      '+': function(element, tag) {
-        while ((element = element.nextSibling)) {
-          if (element.tagName) {
-            return (tag == '*' || element.tagName == tag) ? [element] : [];
-          }
+        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 [];
+    },
+
+    // search for late sibling nodes
+    '~': function(element, tag) {
+      var result = [];
+      while ((element = element.nextSibling)) {
+        if (tag === '*' || element.tagName === tag) {
+          result.push(element);
         }
-        return result;
       }
-    };
+      return result;
+    }
+  },
 
 
-    /**
-     * Collection of pseudo selector matchers
-     */
-    var pseudos = {
-      checked: function() {
-        return this.checked;
-      },
+  /**
+   * Collection of pseudo selector matchers
+   */
+  pseudos = {
+    not: function(node, css_rule) {
+      return node.nodeType === 1 && !RightJS.$(node).match(css_rule);
+    },
 
-      disabled: function() {
-        return this.disabled;
-      },
+    checked: function(node) {
+      return node.checked === true;
+    },
 
-      empty: function() {
-        return !(this.innerText || this.innerHTML || this.textContent || '').length;
-      },
+    enabled: function(node) {
+      return node.disabled === false;
+    },
 
-      'first-child': function(tag_name) {
-        var node = this;
-        while ((node = node.previousSibling)) {
-          if (node.tagName && (!tag_name || node.tagName == tag_name)) {
-            return false;
-          }
-        }
-        return true;
-      },
-
-      'first-of-type': function() {
-        return arguments[1]['first-child'].call(this, this.tagName);
-      },
-
-      'last-child': function(tag_name) {
-        var node = this;
-        while ((node = node.nextSibling)) {
-          if (node.tagName && (!tag_name || node.tagName == tag_name)) {
-            return false;
-          }
-        }
-        return true;
-      },
-
-      'last-of-type': function() {
-        return arguments[1]['last-child'].call(this, this.tagName);
-      },
-
-      'only-child': function(tag_name, matchers) {
-        return matchers['first-child'].call(this, tag_name) &&
-          matchers['last-child'].call(this, tag_name);
-      },
-
-      'only-of-type': function() {
-        return arguments[1]['only-child'].call(this, this.tagName, arguments[1]);
-      },
-
-      'nth-child': function(number, matchers, tag_name) {
-        if (!this.parentNode) { return false; }
-        number = number.toLowerCase();
-
-        if (number == 'n') { return true; }
-
-        if (number.include('n')) {
-          // parsing out the matching expression
-          var a = 0, b = 0;
-          if ((m = number.match(/^([+\-]?\d*)?n([+\-]?\d*)?$/))) {
-            a = m[1] == '-' ? -1 : parseInt(m[1], 10) || 1;
-            b = parseInt(m[2], 10) || 0;
-          }
+    disabled: function(node) {
+      return node.disabled === true;
+    },
 
-          // getting the element index
-          var index = 1, node = this;
-          while ((node = node.previousSibling)) {
-            if (node.tagName && (!tag_name || node.tagName == tag_name)) { index++; }
-          }
+    selected: function(node) {
+      return node.selected === true;
+    },
 
-          return (index - b) % a === 0 && (index - b) / a >= 0;
+    empty: function(node) {
+      return !node.firstChild;
+    },
 
-        } else {
-          return matchers.index.call(this, number.toInt() - 1, matchers, tag_name);
+    'first-child': function(node, node_name) {
+      while ((node = node.previousSibling)) {
+        if (node.nodeType === 1 && (node_name === null || node.nodeName === node_name)) {
+          return false;
         }
-      },
-
-      'nth-of-type': function(number) {
-        return arguments[1]['nth-child'].call(this, number, arguments[1], this.tagName);
-      },
-
-    // protected
-      index: function(number, matchers, tag_name) {
-        number = RightJS.isString(number) ? number.toInt() : number;
-        var node = this, count = 0;
-        while ((node = node.previousSibling)) {
-          if (node.tagName && (!tag_name || node.tagName == tag_name) && ++count > number) { return false; }
-        }
-        return count == number;
       }
-    };
+      return true;
+    },
 
-    // the regexps collection
-    var chunker   = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?/g;
-    var id_re     = /#([\w\-_]+)/;
-    var tag_re    = /^[\w\*]+/;
-    var class_re  = /\.([\w\-\._]+)/;
-    var pseudo_re = /:([\w\-]+)(\((.+?)\))*$/;
-    var attrs_re  = /\[((?:[\w\-]*:)?[\w\-]+)\s*(?:([!\^$*~|]?=)\s*((['"])([^\4]*?)\4|([^'"][^\]]*?)))?\]/;
-
-  /////////////////////////////////////////////////////////////////////////////////////////////////////////
-  /////////////////////////////////////////////////////////////////////////////////////////////////////////
-  /////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    /**
-     * Builds an atom matcher
-     *
-     * @param String atom definition
-     * @return Object atom matcher
-     */
-    var atoms_cache = {};
-    function build_atom(in_atom) {
-      if (!atoms_cache[in_atom]) {
-        var id, tag, classes, 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], '');
-        }
+    'first-of-type': function(node) {
+      return pseudos['first-child'](node, node.nodeName);
+    },
 
-        // extracting the pseudos
-        if ((match = atom.match(pseudo_re))) {
-          pseudo = match[1];
-          values_of_pseudo = match[3] == '' ? null : match[3];
-          atom = atom.replace(match[0], '');
+    '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;
+    },
 
-        // 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('');
-
-        desc.tag = tag;
-
-        //
-        // HACK HACK HACK
-        //
-        // building the matcher function
-        //
-        // NOTE: we kinda compile a cutom filter function in here
-        //       the point is to create a maximally optimized method
-        //       that will make only this atom checks and will filter
-        //       a list of elements in a single call
-        //
-        if (id || classes.length || attrs || pseudo) {
-          var filter = 'function(y){'+
-            'var e,r=[],z=0,x=y.length;'+
-            'for(;z<x;z++){'+
-              'e=y[z];_f_'+
-            '}return r}';
-
-          var patch_filter = function(code) {
-            filter = filter.replace('_f_', code + '_f_');
-          };
-
-          // adding the ID check conditions
-          if (id) { patch_filter('if(e.id!=i)continue;'); }
-
-          // adding the classes matching code
-          if (classes.length) { patch_filter(
-            'if(e.className){'+
-              'var n=e.className.split(" ");'+
-              'if(n.length==1&&c.indexOf(n[0])==-1)continue;'+
-              'else{'+
-                'for(var i=0,l=c.length,b=false;i<l;i++)'+
-                  'if(n.indexOf(c[i])==-1){'+
-                    'b=true;break;}'+
-
-              'if(b)continue;}'+
-            '}else continue;'
-          ); }
-
-          // adding the attributes matching conditions
-          if (attrs) { patch_filter(
-            'var p,o,v,k,b=false;'+
-            'for (k in a){p=e.getAttribute(k)||"";o=a[k].o||"";v=a[k].v||"";'+
-              'if('+
-                '(o===""&&e.getAttributeNode(k)===null)||'+
-                '(o==="="&&p!=v)||'+
-                '(o==="*="&&!p.include(v))||'+
-                '(o==="^="&&!p.startsWith(v))||'+
-                '(o==="$="&&!p.endsWith(v))||'+
-                '(o==="~="&&!p.split(" ").include(v))||'+
-                '(o==="|="&&!p.split("-").include(v))'+
-              '){b=true;break;}'+
-            '}if(b){continue;}'
-          ); }
-
-          // adding the pseudo matchers check
-          if (pseudo in pseudos) {
-            patch_filter('if(!S[P].call(e,V,S))continue;');
-          }
+    'last-of-type': function(node) {
+      return pseudos['last-child'](node, node.nodeName);
+    },
 
-          //
-          // HACK HACK HACK
-          //
-          // Here we separate the names space from the outside
-          // and inside of the function, so that when this thing
-          // is optimized by the code compiler, it kept the necessary
-          // variable names intackt
-          //
-          desc.filter = eval(
-            "[function(i,t,c,a,P,V,S,s){return eval('['+s+']')[0]}]"
-          )[0](
-            id,tag,classes,attrs,pseudo,values_of_pseudo,pseudos,
-            filter.replace('_f_', 'r.push(e)')
-          );
-        }
+    'only-child': function(node, node_name) {
+      return pseudos['first-child'](node, node_name) &&
+        pseudos['last-child'](node, node_name);
+    },
 
-        atoms_cache[in_atom] = desc;
-      }
+    'only-of-type': function(node) {
+      return pseudos['only-child'](node, node.nodeName);
+    },
 
-      return atoms_cache[in_atom];
-    }
+    'nth-child': function(node, number, node_name, reverse) {
+      var index = 1, a = number[0], b = number[1];
 
-    /**
-     * Builds a single selector out of a simple rule chunk
-     *
-     * @param Array of a single rule tokens
-     * @return Function selector
-     */
-    var tokens_cache = {};
-    function build_selector(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]);
+      while ((node = (reverse === true) ? node.nextSibling : node.previousSibling)) {
+        if (node.nodeType === 1 && (node_name === undefined || node.nodeName === node_name)) {
+          index++;
         }
+      }
 
-        // creates a list of uniq nodes
-        var _uid = $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 (b === undefined ? (index === a) : ((index - b) % a === 0 && (index - b) / a >= 0));
+    },
 
-          return uniq;
-        };
+    'nth-of-type': function(node, number) {
+      return pseudos['nth-child'](node, number, node.nodeName);
+    },
 
-        // 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;
-        };
+    'nth-last-child': function(node, number) {
+      return pseudos['nth-child'](node, number, undefined, true);
+    },
 
-        // building the actual selector function
-        tokens_cache[rule_key] = function(element) {
-          var founds, sub_founds;
+    '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];
 
-          for (var i=0, i_length = rule.length; i < i_length; i++) {
-            if (i === 0) {
-              founds = find_subnodes(element, rule[i]);
+        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 {
-              if (i > 1) { founds = uniq(founds); }
+              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;
+                }
+              }
 
-              for (var j=0; j < founds.length; j++) {
-                sub_founds = find_subnodes(founds[j], rule[i]);
+              if (failed) { continue; }
+            }
 
-                sub_founds.unshift(1); // <- nuke the parent node out of the list
-                sub_founds.unshift(j); // <- position to insert the subresult
+            ///////////////////////////////////////////////
+            // 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; }
+              }
 
-                founds.splice.apply(founds, sub_founds);
+              if (failed) { continue; }
+            }
 
-                j += sub_founds.length - 3;
+            ///////////////////////////////////////////////
+            // Pseudo selectors check
+            if (pseudo !== false) {
+              if (!pseudo(node, values_of_pseudo)) {
+                continue;
               }
             }
-          }
 
-          return rule.length > 1 ? uniq(founds) : founds;
+            result[j++] = node;
+          }
+          return result;
         };
       }
-      return tokens_cache[rule_key];
+
+      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;
+      };
 
-    /**
-     * Builds the list of selectors for the css_rule
-     *
-     * @param String raw css-rule
-     * @return Array of selectors
-     */
-    var selectors_cache = {}, chunks_cache = {};
-    function split_rule_to_selectors(css_rule) {
-      if (!selectors_cache[css_rule]) {
-        chunker.lastIndex = 0;
+      // 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;
+      };
 
-        var rules = [], rule = [], rel = ' ', m, token;
-        while ((m = chunker.exec(css_rule))) {
-          token = m[1];
+      // 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]);
 
-          if (token == '+' || token == '>' || token == '~') {
-            rel = token;
           } else {
-            rule.push([rel, token]);
-            rel = ' ';
-          }
+            if (i > 1) { founds = uniq(founds); }
+
+            for (var j=0; j < founds.length; j++) {
+              sub_founds = find_subnodes(founds[j], rule[i]);
 
-          if (m[2]) {
-            rules.push(build_selector(rule));
-            rule = [];
+              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;
+            }
           }
         }
-        rules.push(build_selector(rule));
 
-        selectors_cache[css_rule] = rules;
-      }
-      return selectors_cache[css_rule];
+        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 = ' ';
+        }
 
-
-    /**
-     * 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
-     */
-    function select_all(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));
+        if (m[2]) {
+          rules.push(build_selector(rule));
+          rule = [];
+        }
       }
+      rules.push(build_selector(rule));
 
-      return result;
+      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];
+    },
 
-    // the previous dom-selection methods replacement
-    var 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;
 
-      find: function(css_rule) {
-        return select_all(this._, css_rule || '*').map(RightJS.$);
+      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);
       }
-    };
 
-    dom_extension.select = dom_extension.find;
+      return raw === true ? result : result.map(RightJS.$);
+    }
+  };
 
-    // hooking up the rightjs wrappers with the new methods
-    RightJS.Element.include(dom_extension);
-    RightJS.Document.include(dom_extension);
-  })(RightJS);
+  // hooking up the rightjs wrappers with the new methods
+  RightJS.$ext(RightJS.Element.prototype, dom_extension);
+  RightJS.$ext(RightJS.Document.prototype, dom_extension);
 }
+})(RightJS);