1 files changed, 11 insertions, 5 deletions

diff --git a/frontend/gamma/js/MochiKit/Selector.js b/frontend/gamma/js/MochiKit/Selector.js
index 6aec892..3187fe9 100644
--- a/frontend/gamma/js/MochiKit/Selector.js
+++ b/frontend/gamma/js/MochiKit/Selector.js
@@ -1,35 +1,35 @@
 /***
 
 MochiKit.Selector 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito and others.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Selector', '1.5', ['Base', 'DOM', 'Iter']);
+MochiKit.Base.module(MochiKit, 'Selector', '1.5', ['Base', 'DOM', 'Iter']);
 
 MochiKit.Selector.Selector = function (expression) {
     this.params = {classNames: [], pseudoClassNames: []};
     this.expression = expression.toString().replace(/(^\s+|\s+$)/g, '');
     this.parseExpression();
     this.compileMatcher();
 };
 
 MochiKit.Selector.Selector.prototype = {
     /***
 
     Selector class: convenient object to make CSS selections.
 
     ***/
     __class__: MochiKit.Selector.Selector,
 
     /** @id MochiKit.Selector.Selector.prototype.parseExpression */
     parseExpression: function () {
         function abort(message) {
             throw 'Parse error in selector: ' + message;
         }
 
         if (this.expression == '')  {
             abort('empty expression');
@@ -106,99 +106,99 @@ MochiKit.Selector.Selector.prototype = {
         if ((clause = params.pseudoClassNames).length > 0) {
             for (i = 0; i < clause.length; i++) {
                 var match = clause[i].match(/^([^(]+)(?:\((.*)\))?$/);
                 var pseudoClass = match[1];
                 var pseudoClassArgument = match[2];
                 switch (pseudoClass) {
                     case 'root':
                         conditions.push('element.nodeType == 9 || element === element.ownerDocument.documentElement'); break;
                     case 'nth-child':
                     case 'nth-last-child':
                     case 'nth-of-type':
                     case 'nth-last-of-type':
                         match = pseudoClassArgument.match(/^((?:(\d+)n\+)?(\d+)|odd|even)$/);
                         if (!match) {
                             throw "Invalid argument to pseudo element nth-child: " + pseudoClassArgument;
                         }
                         var a, b;
                         if (match[0] == 'odd') {
                             a = 2;
                             b = 1;
                         } else if (match[0] == 'even') {
                             a = 2;
                             b = 0;
                         } else {
-                            a = match[2] && parseInt(match) || null;
-                            b = parseInt(match[3]);
+                            a = match[2] && parseInt(match, 10) || null;
+                            b = parseInt(match[3], 10);
                         }
                         conditions.push('this.nthChild(element,' + a + ',' + b
                                         + ',' + !!pseudoClass.match('^nth-last')    // Reverse
                                         + ',' + !!pseudoClass.match('of-type$')     // Restrict to same tagName
                                         + ')');
                         break;
                     case 'first-child':
                         conditions.push('this.nthChild(element, null, 1)');
                         break;
                     case 'last-child':
                         conditions.push('this.nthChild(element, null, 1, true)');
                         break;
                     case 'first-of-type':
                         conditions.push('this.nthChild(element, null, 1, false, true)');
                         break;
                     case 'last-of-type':
                         conditions.push('this.nthChild(element, null, 1, true, true)');
                         break;
                     case 'only-child':
                         conditions.push(childElements('element.parentNode') + '.length == 1');
                         break;
                     case 'only-of-type':
                         conditions.push('MochiKit.Base.filter(function (node) { return node.tagName == element.tagName; }, ' + childElements('element.parentNode') + ').length == 1');
                         break;
                     case 'empty':
                         conditions.push('element.childNodes.length == 0');
                         break;
                     case 'enabled':
                         conditions.push('(this.isUIElement(element) && element.disabled === false)');
                         break;
                     case 'disabled':
                         conditions.push('(this.isUIElement(element) && element.disabled === true)');
                         break;
                     case 'checked':
                         conditions.push('(this.isUIElement(element) && element.checked === true)');
                         break;
                     case 'not':
                         var subselector = new MochiKit.Selector.Selector(pseudoClassArgument);
-                        conditions.push('!( ' + subselector.buildMatchExpression() + ')')
+                        conditions.push('!( ' + subselector.buildMatchExpression() + ')');
                         break;
                 }
             }
         }
         if (clause = params.attributes) {
             MochiKit.Base.map(function (attribute) {
                 var value = 'MochiKit.DOM.getNodeAttribute(element, ' + repr(attribute.name) + ')';
                 var splitValueBy = function (delimiter) {
                     return value + '.split(' + repr(delimiter) + ')';
-                }
+                };
                 conditions.push(value + ' != null');
                 switch (attribute.operator) {
                     case '=':
                         conditions.push(value + ' == ' + repr(attribute.value));
                         break;
                     case '~=':
                         conditions.push('MochiKit.Base.findValue(' + splitValueBy(' ') + ', ' + repr(attribute.value) + ') > -1');
                         break;
                     case '^=':
                         conditions.push(value + '.substring(0, ' + attribute.value.length + ') == ' + repr(attribute.value));
                         break;
                     case '$=':
                         conditions.push(value + '.substring(' + value + '.length - ' + attribute.value.length + ') == ' + repr(attribute.value));
                         break;
                     case '*=':
                         conditions.push(value + '.match(' + repr(attribute.value) + ')');
                         break;
                     case '|=':
                         conditions.push(splitValueBy('-') + '[0].toUpperCase() == ' + repr(attribute.value.toUpperCase()));
                         break;
                     case '!=':
                         conditions.push(value + ' != ' + repr(attribute.value));
                         break;
                     case '':
@@ -331,48 +331,54 @@ MochiKit.Selector.Selector.prototype = {
 
     /** @id MochiKit.Selector.Selector.prototype.repr */
     repr: function () {
         return 'Selector(' + this.expression + ')';
     },
 
     toString: MochiKit.Base.forwardCall("repr")
 };
 
 MochiKit.Base.update(MochiKit.Selector, {
 
     /** @id MochiKit.Selector.findChildElements */
     findChildElements: function (element, expressions) {
         element = MochiKit.DOM.getElement(element);
         var uniq = function(arr) {
             var res = [];
             for (var i = 0; i < arr.length; i++) {
                 if (MochiKit.Base.findIdentical(res, arr[i]) < 0) {
                     res.push(arr[i]);
                 }
             }
             return res;
         };
         return MochiKit.Base.flattenArray(MochiKit.Base.map(function (expression) {
+            try {
+                var res = element.querySelectorAll(expression);
+                return Array.prototype.slice.call(res, 0);
+            } catch (ignore) {
+                // No querySelectorAll or extended expression syntax used
+            }
             var nextScope = "";
             var reducer = function (results, expr) {
                 var match = expr.match(/^[>+~]$/);
                 if (match) {
                     nextScope = match[0];
                     return results;
                 } else {
                     var selector = new MochiKit.Selector.Selector(expr);
                     var elements = MochiKit.Iter.reduce(function (elements, result) {
                         return MochiKit.Base.extend(elements, selector.findElements(result || element, nextScope));
                     }, results, []);
                     nextScope = "";
                     return elements;
                 }
             };
             var exprs = expression.replace(/(^\s+|\s+$)/g, '').split(/\s+/);
             return uniq(MochiKit.Iter.reduce(reducer, exprs, [null]));
         }, expressions));
     },
 
     findDocElements: function () {
         return MochiKit.Selector.findChildElements(MochiKit.DOM.currentDocument(), arguments);
     },