WordPress.org

Make WordPress Core

Changeset 5792


Ignore:
Timestamp:
07/09/2007 08:14:28 PM (12 years ago)
Author:
ryan
Message:

Update to scriptaculous 1.7.1_beta3. Props Nazgul. fixes #4512

Location:
trunk/wp-includes/js/scriptaculous
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/wp-includes/js/scriptaculous/MIT-LICENSE

    r4813 r5792  
    1 Copyright (c) 2005, 2006 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
     1Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
    22
    33Permission is hereby granted, free of charge, to any person obtaining
  • trunk/wp-includes/js/scriptaculous/builder.js

    r5482 r5792  
    1 // script.aculo.us builder.js v1.7.1_beta2, Sat Apr 28 15:20:12 CEST 2007
     1// script.aculo.us builder.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007
    22
    33// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
     
    9090    for(attribute in attributes)
    9191      attrs.push((attribute in this.ATTR_MAP ? this.ATTR_MAP[attribute] : attribute) +
    92           '="' + attributes[attribute].toString().escapeHTML() + '"');
     92          '="' + attributes[attribute].toString().escapeHTML().gsub(/"/,'"') + '"');
    9393    return attrs.join(" ");
    9494  },
  • trunk/wp-includes/js/scriptaculous/controls.js

    r5482 r5792  
    1 // script.aculo.us controls.js v1.7.1_beta2, Sat Apr 28 15:20:12 CEST 2007
     1// script.aculo.us controls.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007
    22
    33// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
  • trunk/wp-includes/js/scriptaculous/dragdrop.js

    r5482 r5792  
    1 // script.aculo.us dragdrop.js v1.7.1_beta2, Sat Apr 28 15:20:12 CEST 2007
     1// script.aculo.us dragdrop.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007
    22
    33// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
     
    639639      scrollSpeed: 15,
    640640      format:      this.SERIALIZE_RULE,
     641     
     642      // these take arrays of elements or ids and can be
     643      // used for better initialization performance
     644      elements:    false,
     645      handles:     false,
     646
    641647      onChange:    Prototype.emptyFunction,
    642648      onUpdate:    Prototype.emptyFunction
     
    703709    }
    704710
    705     (this.findElements(element, options) || []).each( function(e) {
    706       // handles are per-draggable
    707       var handle = options.handle ?
    708         $(e).down('.'+options.handle,0) : e;   
     711    (options.elements || this.findElements(element, options) || []).each( function(e,i) {
     712      var handle = options.handles ? $(options.handles[i]) :
     713        (options.handle ? $(e).getElementsByClassName(options.handle)[0] : e);
    709714      options.draggables.push(
    710715        new Draggable(e, Object.extend(options_for_draggable, { handle: handle })));
  • trunk/wp-includes/js/scriptaculous/effects.js

    r5482 r5792  
    1 // script.aculo.us effects.js v1.7.1_beta2, Sat Apr 28 15:20:12 CEST 2007
     1// script.aculo.us effects.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007
    22
    33// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
  • trunk/wp-includes/js/scriptaculous/prototype.js

    r4813 r5792  
    1 /*  Prototype JavaScript framework, version 1.5.0
     1/*  Prototype JavaScript framework, version 1.5.1.1
    22 *  (c) 2005-2007 Sam Stephenson
    33 *
    44 *  Prototype is freely distributable under the terms of an MIT-style license.
    5  *  For details, see the Prototype web site: http://prototype.conio.net/
     5 *  For details, see the Prototype web site: http://www.prototypejs.org/
    66 *
    77/*--------------------------------------------------------------------------*/
    88
    99var Prototype = {
    10   Version: '1.5.0',
     10  Version: '1.5.1.1',
     11
     12  Browser: {
     13    IE:     !!(window.attachEvent && !window.opera),
     14    Opera:  !!window.opera,
     15    WebKit: navigator.userAgent.indexOf('AppleWebKit/') > -1,
     16    Gecko:  navigator.userAgent.indexOf('Gecko') > -1 && navigator.userAgent.indexOf('KHTML') == -1
     17  },
     18
    1119  BrowserFeatures: {
    12     XPath: !!document.evaluate
    13   },
    14 
    15   ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)',
    16   emptyFunction: function() {},
     20    XPath: !!document.evaluate,
     21    ElementExtensions: !!window.HTMLElement,
     22    SpecificElementExtensions:
     23      (document.createElement('div').__proto__ !==
     24       document.createElement('form').__proto__)
     25  },
     26
     27  ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',
     28  JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,
     29
     30  emptyFunction: function() { },
    1731  K: function(x) { return x }
    1832}
     
    4761  },
    4862
     63  toJSON: function(object) {
     64    var type = typeof object;
     65    switch(type) {
     66      case 'undefined':
     67      case 'function':
     68      case 'unknown': return;
     69      case 'boolean': return object.toString();
     70    }
     71    if (object === null) return 'null';
     72    if (object.toJSON) return object.toJSON();
     73    if (object.ownerDocument === document) return;
     74    var results = [];
     75    for (var property in object) {
     76      var value = Object.toJSON(object[property]);
     77      if (value !== undefined)
     78        results.push(property.toJSON() + ': ' + value);
     79    }
     80    return '{' + results.join(', ') + '}';
     81  },
     82
    4983  keys: function(object) {
    5084    var keys = [];
     
    76110  var __method = this, args = $A(arguments), object = args.shift();
    77111  return function(event) {
    78     return __method.apply(object, [( event || window.event)].concat(args).concat($A(arguments)));
     112    return __method.apply(object, [event || window.event].concat(args));
    79113  }
    80114}
     
    82116Object.extend(Number.prototype, {
    83117  toColorPart: function() {
    84     var digits = this.toString(16);
    85     if (this < 16) return '0' + digits;
    86     return digits;
     118    return this.toPaddedString(2, 16);
    87119  },
    88120
     
    94126    $R(0, this, true).each(iterator);
    95127    return this;
     128  },
     129
     130  toPaddedString: function(length, radix) {
     131    var string = this.toString(radix || 10);
     132    return '0'.times(length - string.length) + string;
     133  },
     134
     135  toJSON: function() {
     136    return isFinite(this) ? this.toString() : 'null';
    96137  }
    97138});
     139
     140Date.prototype.toJSON = function() {
     141  return '"' + this.getFullYear() + '-' +
     142    (this.getMonth() + 1).toPaddedString(2) + '-' +
     143    this.getDate().toPaddedString(2) + 'T' +
     144    this.getHours().toPaddedString(2) + ':' +
     145    this.getMinutes().toPaddedString(2) + ':' +
     146    this.getSeconds().toPaddedString(2) + '"';
     147};
    98148
    99149var Try = {
     
    146196  }
    147197}
    148 String.interpret = function(value){
    149   return value == null ? '' : String(value);
    150 }
     198Object.extend(String, {
     199  interpret: function(value) {
     200    return value == null ? '' : String(value);
     201  },
     202  specialChar: {
     203    '\b': '\\b',
     204    '\t': '\\t',
     205    '\n': '\\n',
     206    '\f': '\\f',
     207    '\r': '\\r',
     208    '\\': '\\\\'
     209  }
     210});
    151211
    152212Object.extend(String.prototype, {
     
    214274
    215275  escapeHTML: function() {
    216     var div = document.createElement('div');
    217     var text = document.createTextNode(this);
    218     div.appendChild(text);
    219     return div.innerHTML;
     276    var self = arguments.callee;
     277    self.text.data = this;
     278    return self.div.innerHTML;
    220279  },
    221280
     
    224283    div.innerHTML = this.stripTags();
    225284    return div.childNodes[0] ? (div.childNodes.length > 1 ?
    226       $A(div.childNodes).inject('',function(memo,node){ return memo+node.nodeValue }) :
     285      $A(div.childNodes).inject('', function(memo, node) { return memo+node.nodeValue }) :
    227286      div.childNodes[0].nodeValue) : '';
    228287  },
     
    234293    return match[1].split(separator || '&').inject({}, function(hash, pair) {
    235294      if ((pair = pair.split('='))[0]) {
    236         var name = decodeURIComponent(pair[0]);
    237         var value = pair[1] ? decodeURIComponent(pair[1]) : undefined;
    238 
    239         if (hash[name] !== undefined) {
    240           if (hash[name].constructor != Array)
    241             hash[name] = [hash[name]];
    242           if (value) hash[name].push(value);
     295        var key = decodeURIComponent(pair.shift());
     296        var value = pair.length > 1 ? pair.join('=') : pair[0];
     297        if (value != undefined) value = decodeURIComponent(value);
     298
     299        if (key in hash) {
     300          if (hash[key].constructor != Array) hash[key] = [hash[key]];
     301          hash[key].push(value);
    243302        }
    244         else hash[name] = value;
     303        else hash[key] = value;
    245304      }
    246305      return hash;
     
    257316  },
    258317
     318  times: function(count) {
     319    var result = '';
     320    for (var i = 0; i < count; i++) result += this;
     321    return result;
     322  },
     323
    259324  camelize: function() {
    260325    var parts = this.split('-'), len = parts.length;
     
    271336  },
    272337
    273   capitalize: function(){
     338  capitalize: function() {
    274339    return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
    275340  },
     
    284349
    285350  inspect: function(useDoubleQuotes) {
    286     var escapedString = this.replace(/\\/g, '\\\\');
    287     if (useDoubleQuotes)
    288       return '"' + escapedString.replace(/"/g, '\\"') + '"';
    289     else
    290       return "'" + escapedString.replace(/'/g, '\\\'') + "'";
     351    var escapedString = this.gsub(/[\x00-\x1f\\]/, function(match) {
     352      var character = String.specialChar[match[0]];
     353      return character ? character : '\\u00' + match[0].charCodeAt().toPaddedString(2, 16);
     354    });
     355    if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
     356    return "'" + escapedString.replace(/'/g, '\\\'') + "'";
     357  },
     358
     359  toJSON: function() {
     360    return this.inspect(true);
     361  },
     362
     363  unfilterJSON: function(filter) {
     364    return this.sub(filter || Prototype.JSONFilter, '#{1}');
     365  },
     366
     367  isJSON: function() {
     368    var str = this.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');
     369    return (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(str);
     370  },
     371
     372  evalJSON: function(sanitize) {
     373    var json = this.unfilterJSON();
     374    try {
     375      if (!sanitize || json.isJSON()) return eval('(' + json + ')');
     376    } catch (e) { }
     377    throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
     378  },
     379
     380  include: function(pattern) {
     381    return this.indexOf(pattern) > -1;
     382  },
     383
     384  startsWith: function(pattern) {
     385    return this.indexOf(pattern) === 0;
     386  },
     387
     388  endsWith: function(pattern) {
     389    var d = this.length - pattern.length;
     390    return d >= 0 && this.lastIndexOf(pattern) === d;
     391  },
     392
     393  empty: function() {
     394    return this == '';
     395  },
     396
     397  blank: function() {
     398    return /^\s*$/.test(this);
     399  }
     400});
     401
     402if (Prototype.Browser.WebKit || Prototype.Browser.IE) Object.extend(String.prototype, {
     403  escapeHTML: function() {
     404    return this.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
     405  },
     406  unescapeHTML: function() {
     407    return this.replace(/&amp;/g,'&').replace(/&lt;/g,'<').replace(/&gt;/g,'>');
    291408  }
    292409});
     
    299416
    300417String.prototype.parseQuery = String.prototype.toQueryParams;
     418
     419Object.extend(String.prototype.escapeHTML, {
     420  div:  document.createElement('div'),
     421  text: document.createTextNode('')
     422});
     423
     424with (String.prototype.escapeHTML) div.appendChild(text);
    301425
    302426var Template = Class.create();
     
    317441}
    318442
    319 var $break    = new Object();
    320 var $continue = new Object();
     443var $break = {}, $continue = new Error('"throw $continue" is deprecated, use "return" instead');
    321444
    322445var Enumerable = {
     
    325448    try {
    326449      this._each(function(value) {
    327         try {
    328           iterator(value, index++);
    329         } catch (e) {
    330           if (e != $continue) throw e;
    331         }
     450        iterator(value, index++);
    332451      });
    333452    } catch (e) {
     
    531650}
    532651
     652if (Prototype.Browser.WebKit) {
     653  $A = Array.from = function(iterable) {
     654    if (!iterable) return [];
     655    if (!(typeof iterable == 'function' && iterable == '[object NodeList]') &&
     656      iterable.toArray) {
     657      return iterable.toArray();
     658    } else {
     659      var results = [];
     660      for (var i = 0, length = iterable.length; i < length; i++)
     661        results.push(iterable[i]);
     662      return results;
     663    }
     664  }
     665}
     666
    533667Object.extend(Array.prototype, Enumerable);
    534668
     
    589723  },
    590724
    591   uniq: function() {
    592     return this.inject([], function(array, value) {
    593       return array.include(value) ? array : array.concat([value]);
     725  uniq: function(sorted) {
     726    return this.inject([], function(array, value, index) {
     727      if (0 == index || (sorted ? array.last() != value : !array.include(value)))
     728        array.push(value);
     729      return array;
    594730    });
    595731  },
     
    605741  inspect: function() {
    606742    return '[' + this.map(Object.inspect).join(', ') + ']';
     743  },
     744
     745  toJSON: function() {
     746    var results = [];
     747    this.each(function(object) {
     748      var value = Object.toJSON(object);
     749      if (value !== undefined) results.push(value);
     750    });
     751    return '[' + results.join(', ') + ']';
    607752  }
    608753});
     
    610755Array.prototype.toArray = Array.prototype.clone;
    611756
    612 function $w(string){
     757function $w(string) {
    613758  string = string.strip();
    614759  return string ? string.split(/\s+/) : [];
    615760}
    616761
    617 if(window.opera){
    618   Array.prototype.concat = function(){
     762if (Prototype.Browser.Opera){
     763  Array.prototype.concat = function() {
    619764    var array = [];
    620     for(var i = 0, length = this.length; i < length; i++) array.push(this[i]);
    621     for(var i = 0, length = arguments.length; i < length; i++) {
    622       if(arguments[i].constructor == Array) {
    623         for(var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)
     765    for (var i = 0, length = this.length; i < length; i++) array.push(this[i]);
     766    for (var i = 0, length = arguments.length; i < length; i++) {
     767      if (arguments[i].constructor == Array) {
     768        for (var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)
    624769          array.push(arguments[i][j]);
    625770      } else {
     
    630775  }
    631776}
    632 var Hash = function(obj) {
    633   Object.extend(this, obj || {});
     777var Hash = function(object) {
     778  if (object instanceof Hash) this.merge(object);
     779  else Object.extend(this, object || {});
    634780};
    635781
     
    637783  toQueryString: function(obj) {
    638784    var parts = [];
    639 
    640       this.prototype._each.call(obj, function(pair) {
     785    parts.add = arguments.callee.addPair;
     786
     787    this.prototype._each.call(obj, function(pair) {
    641788      if (!pair.key) return;
    642 
    643       if (pair.value && pair.value.constructor == Array) {
    644         var values = pair.value.compact();
    645         if (values.length < 2) pair.value = values.reduce();
    646         else {
    647             key = encodeURIComponent(pair.key);
    648           values.each(function(value) {
    649             value = value != undefined ? encodeURIComponent(value) : '';
    650             parts.push(key + '=' + encodeURIComponent(value));
    651           });
    652           return;
    653         }
     789      var value = pair.value;
     790
     791      if (value && typeof value == 'object') {
     792        if (value.constructor == Array) value.each(function(value) {
     793          parts.add(pair.key, value);
     794        });
     795        return;
    654796      }
    655       if (pair.value == undefined) pair[1] = '';
    656       parts.push(pair.map(encodeURIComponent).join('='));
    657       });
     797      parts.add(pair.key, value);
     798    });
    658799
    659800    return parts.join('&');
     801  },
     802
     803  toJSON: function(object) {
     804    var results = [];
     805    this.prototype._each.call(object, function(pair) {
     806      var value = Object.toJSON(pair.value);
     807      if (value !== undefined) results.push(pair.key.toJSON() + ': ' + value);
     808    });
     809    return '{' + results.join(', ') + '}';
    660810  }
    661811});
     812
     813Hash.toQueryString.addPair = function(key, value, prefix) {
     814  key = encodeURIComponent(key);
     815  if (value === undefined) this.push(key);
     816  else this.push(key + '=' + (value == null ? '' : encodeURIComponent(value)));
     817}
    662818
    663819Object.extend(Hash.prototype, Enumerable);
     
    714870      return pair.map(Object.inspect).join(': ');
    715871    }).join(', ') + '}>';
     872  },
     873
     874  toJSON: function() {
     875    return Hash.toJSON(this);
    716876  }
    717877});
    718878
    719879function $H(object) {
    720   if (object && object.constructor == Hash) return object;
     880  if (object instanceof Hash) return object;
    721881  return new Hash(object);
     882};
     883
     884// Safari iterates over shadowed properties
     885if (function() {
     886  var i = 0, Test = function(value) { this.key = value };
     887  Test.prototype.key = 'foo';
     888  for (var property in new Test('bar')) i++;
     889  return i > 1;
     890}()) Hash.prototype._each = function(iterator) {
     891  var cache = [];
     892  for (var key in this) {
     893    var value = this[key];
     894    if ((value && value == Hash.prototype[key]) || cache.include(key)) continue;
     895    cache.push(key);
     896    var pair = [key, value];
     897    pair.key = key;
     898    pair.value = value;
     899    iterator(pair);
     900  }
    722901};
    723902ObjectRange = Class.create();
     
    8351014    this.url = url;
    8361015    this.method = this.options.method;
    837     var params = this.options.parameters;
     1016    var params = Object.clone(this.options.parameters);
    8381017
    8391018    if (!['get', 'post'].include(this.method)) {
     
    8431022    }
    8441023
    845     params = Hash.toQueryString(params);
    846     if (params && /Konqueror|Safari|KHTML/.test(navigator.userAgent)) params += '&_='
    847 
    848     // when GET, append parameters to URL
    849     if (this.method == 'get' && params)
    850       this.url += (this.url.indexOf('?') > -1 ? '&' : '?') + params;
     1024    this.parameters = params;
     1025
     1026    if (params = Hash.toQueryString(params)) {
     1027      // when GET, append parameters to URL
     1028      if (this.method == 'get')
     1029        this.url += (this.url.include('?') ? '&' : '?') + params;
     1030      else if (/Konqueror|Safari|KHTML/.test(navigator.userAgent))
     1031        params += '&_=';
     1032    }
    8511033
    8521034    try {
     1035      if (this.options.onCreate) this.options.onCreate(this.transport);
    8531036      Ajax.Responders.dispatch('onCreate', this, this.transport);
    8541037
     
    8621045      this.setRequestHeaders();
    8631046
    864       var body = this.method == 'post' ? (this.options.postBody || params) : null;
    865 
    866       this.transport.send(body);
     1047      this.body = this.method == 'post' ? (this.options.postBody || params) : null;
     1048      this.transport.send(this.body);
    8671049
    8681050      /* Force Firefox to handle ready state 4 for synchronous requests */
     
    9361118      }
    9371119
    938       if ((this.getHeader('Content-type') || 'text/javascript').strip().
     1120      var contentType = this.getHeader('Content-type');
     1121      if (contentType && contentType.strip().
    9391122        match(/^(text|application)\/(x-)?(java|ecma)script(;.*)?$/i))
    9401123          this.evalResponse();
     
    9631146    try {
    9641147      var json = this.getHeader('X-JSON');
    965       return json ? eval('(' + json + ')') : null;
     1148      return json ? json.evalJSON() : null;
    9661149    } catch (e) { return null }
    9671150  },
     
    9691152  evalResponse: function() {
    9701153    try {
    971       return eval(this.transport.responseText);
     1154      return eval((this.transport.responseText || '').unfilterJSON());
    9721155    } catch (e) {
    9731156      this.dispatchException(e);
     
    10841267    return results;
    10851268  };
    1086 }
    1087 
    1088 document.getElementsByClassName = function(className, parentElement) {
    1089   if (Prototype.BrowserFeatures.XPath) {
     1269
     1270  document.getElementsByClassName = function(className, parentElement) {
    10901271    var q = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
    10911272    return document._getElementsByXPath(q, parentElement);
    1092   } else {
    1093     var children = ($(parentElement) || document.body).getElementsByTagName('*');
    1094     var elements = [], child;
    1095     for (var i = 0, length = children.length; i < length; i++) {
    1096       child = children[i];
    1097       if (Element.hasClassName(child, className))
    1098         elements.push(Element.extend(child));
    1099     }
    1100     return elements;
    1101   }
     1273  }
     1274
     1275} else document.getElementsByClassName = function(className, parentElement) {
     1276  var children = ($(parentElement) || document.body).getElementsByTagName('*');
     1277  var elements = [], child, pattern = new RegExp("(^|\\s)" + className + "(\\s|$)");
     1278  for (var i = 0, length = children.length; i < length; i++) {
     1279    child = children[i];
     1280    var elementClassName = child.className;
     1281    if (elementClassName.length == 0) continue;
     1282    if (elementClassName == className || elementClassName.match(pattern))
     1283      elements.push(Element.extend(child));
     1284  }
     1285  return elements;
    11021286};
    11031287
    11041288/*--------------------------------------------------------------------------*/
    11051289
    1106 if (!window.Element)
    1107   var Element = new Object();
     1290if (!window.Element) var Element = {};
    11081291
    11091292Element.extend = function(element) {
    1110   if (!element || _nativeExtensions || element.nodeType == 3) return element;
    1111 
    1112   if (!element._extended && element.tagName && element != window) {
    1113     var methods = Object.clone(Element.Methods), cache = Element.extend.cache;
    1114 
    1115     if (element.tagName == 'FORM')
    1116       Object.extend(methods, Form.Methods);
    1117     if (['INPUT', 'TEXTAREA', 'SELECT'].include(element.tagName))
    1118       Object.extend(methods, Form.Element.Methods);
    1119 
     1293  var F = Prototype.BrowserFeatures;
     1294  if (!element || !element.tagName || element.nodeType == 3 ||
     1295   element._extended || F.SpecificElementExtensions || element == window)
     1296    return element;
     1297
     1298  var methods = {}, tagName = element.tagName, cache = Element.extend.cache,
     1299   T = Element.Methods.ByTag;
     1300
     1301  // extend methods for all tags (Safari doesn't need this)
     1302  if (!F.ElementExtensions) {
     1303    Object.extend(methods, Element.Methods),
    11201304    Object.extend(methods, Element.Methods.Simulated);
    1121 
    1122     for (var property in methods) {
    1123       var value = methods[property];
    1124       if (typeof value == 'function' && !(property in element))
    1125         element[property] = cache.findOrStore(value);
    1126     }
    1127   }
    1128 
    1129   element._extended = true;
     1305  }
     1306
     1307  // extend methods for specific tags
     1308  if (T[tagName]) Object.extend(methods, T[tagName]);
     1309
     1310  for (var property in methods) {
     1311    var value = methods[property];
     1312    if (typeof value == 'function' && !(property in element))
     1313      element[property] = cache.findOrStore(value);
     1314  }
     1315
     1316  element._extended = Prototype.emptyFunction;
    11301317  return element;
    11311318};
     
    12131400
    12141401  descendants: function(element) {
    1215     return $A($(element).getElementsByTagName('*'));
     1402    return $A($(element).getElementsByTagName('*')).each(Element.extend);
     1403  },
     1404
     1405  firstDescendant: function(element) {
     1406    element = $(element).firstChild;
     1407    while (element && element.nodeType != 1) element = element.nextSibling;
     1408    return $(element);
    12161409  },
    12171410
     
    12431436
    12441437  up: function(element, expression, index) {
    1245     return Selector.findElement($(element).ancestors(), expression, index);
     1438    element = $(element);
     1439    if (arguments.length == 1) return $(element.parentNode);
     1440    var ancestors = element.ancestors();
     1441    return expression ? Selector.findElement(ancestors, expression, index) :
     1442      ancestors[index || 0];
    12461443  },
    12471444
    12481445  down: function(element, expression, index) {
    1249     return Selector.findElement($(element).descendants(), expression, index);
     1446    element = $(element);
     1447    if (arguments.length == 1) return element.firstDescendant();
     1448    var descendants = element.descendants();
     1449    return expression ? Selector.findElement(descendants, expression, index) :
     1450      descendants[index || 0];
    12501451  },
    12511452
    12521453  previous: function(element, expression, index) {
    1253     return Selector.findElement($(element).previousSiblings(), expression, index);
     1454    element = $(element);
     1455    if (arguments.length == 1) return $(Selector.handlers.previousElementSibling(element));
     1456    var previousSiblings = element.previousSiblings();
     1457    return expression ? Selector.findElement(previousSiblings, expression, index) :
     1458      previousSiblings[index || 0];
    12541459  },
    12551460
    12561461  next: function(element, expression, index) {
    1257     return Selector.findElement($(element).nextSiblings(), expression, index);
     1462    element = $(element);
     1463    if (arguments.length == 1) return $(Selector.handlers.nextElementSibling(element));
     1464    var nextSiblings = element.nextSiblings();
     1465    return expression ? Selector.findElement(nextSiblings, expression, index) :
     1466      nextSiblings[index || 0];
    12581467  },
    12591468
     
    12691478  readAttribute: function(element, name) {
    12701479    element = $(element);
    1271     if (document.all && !window.opera) {
     1480    if (Prototype.Browser.IE) {
     1481      if (!element.attributes) return null;
    12721482      var t = Element._attributeTranslations;
    12731483      if (t.values[name]) return t.values[name](element, name);
    12741484      if (t.names[name])  name = t.names[name];
    12751485      var attribute = element.attributes[name];
    1276       if(attribute) return attribute.nodeValue;
     1486      return attribute ? attribute.nodeValue : null;
    12771487    }
    12781488    return element.getAttribute(name);
     
    13431553
    13441554  empty: function(element) {
    1345     return $(element).innerHTML.match(/^\s*$/);
     1555    return $(element).innerHTML.blank();
    13461556  },
    13471557
     
    13621572  getStyle: function(element, style) {
    13631573    element = $(element);
    1364     if (['float','cssFloat'].include(style))
    1365       style = (typeof element.style.styleFloat != 'undefined' ? 'styleFloat' : 'cssFloat');
    1366     style = style.camelize();
     1574    style = style == 'float' ? 'cssFloat' : style.camelize();
    13671575    var value = element.style[style];
    13681576    if (!value) {
    1369       if (document.defaultView && document.defaultView.getComputedStyle) {
    1370         var css = document.defaultView.getComputedStyle(element, null);
    1371         value = css ? css[style] : null;
    1372       } else if (element.currentStyle) {
    1373         value = element.currentStyle[style];
    1374       }
    1375     }
    1376 
    1377     if((value == 'auto') && ['width','height'].include(style) && (element.getStyle('display') != 'none'))
    1378       value = element['offset'+style.capitalize()] + 'px';
    1379 
    1380     if (window.opera && ['left', 'top', 'right', 'bottom'].include(style))
    1381       if (Element.getStyle(element, 'position') == 'static') value = 'auto';
    1382     if(style == 'opacity') {
    1383       if(value) return parseFloat(value);
    1384       if(value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
    1385         if(value[1]) return parseFloat(value[1]) / 100;
    1386       return 1.0;
    1387     }
     1577      var css = document.defaultView.getComputedStyle(element, null);
     1578      value = css ? css[style] : null;
     1579    }
     1580    if (style == 'opacity') return value ? parseFloat(value) : 1.0;
    13881581    return value == 'auto' ? null : value;
    13891582  },
    13901583
    1391   setStyle: function(element, style) {
    1392     element = $(element);
    1393     for (var name in style) {
    1394       var value = style[name];
    1395       if(name == 'opacity') {
    1396         if (value == 1) {
    1397           value = (/Gecko/.test(navigator.userAgent) &&
    1398             !/Konqueror|Safari|KHTML/.test(navigator.userAgent)) ? 0.999999 : 1.0;
    1399           if(/MSIE/.test(navigator.userAgent) && !window.opera)
    1400             element.style.filter = element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'');
    1401         } else if(value == '') {
    1402           if(/MSIE/.test(navigator.userAgent) && !window.opera)
    1403             element.style.filter = element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'');
    1404         } else {
    1405           if(value < 0.00001) value = 0;
    1406           if(/MSIE/.test(navigator.userAgent) && !window.opera)
    1407             element.style.filter = element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'') +
    1408               'alpha(opacity='+value*100+')';
    1409         }
    1410       } else if(['float','cssFloat'].include(name)) name = (typeof element.style.styleFloat != 'undefined') ? 'styleFloat' : 'cssFloat';
    1411       element.style[name.camelize()] = value;
    1412     }
     1584  getOpacity: function(element) {
     1585    return $(element).getStyle('opacity');
     1586  },
     1587
     1588  setStyle: function(element, styles, camelized) {
     1589    element = $(element);
     1590    var elementStyle = element.style;
     1591
     1592    for (var property in styles)
     1593      if (property == 'opacity') element.setOpacity(styles[property])
     1594      else
     1595        elementStyle[(property == 'float' || property == 'cssFloat') ?
     1596          (elementStyle.styleFloat === undefined ? 'cssFloat' : 'styleFloat') :
     1597          (camelized ? property : property.camelize())] = styles[property];
     1598
     1599    return element;
     1600  },
     1601
     1602  setOpacity: function(element, value) {
     1603    element = $(element);
     1604    element.style.opacity = (value == 1 || value === '') ? '' :
     1605      (value < 0.00001) ? 0 : value;
    14131606    return element;
    14141607  },
     
    14841677};
    14851678
    1486 Object.extend(Element.Methods, {childOf: Element.Methods.descendantOf});
    1487 
    1488 Element._attributeTranslations = {};
    1489 
    1490 Element._attributeTranslations.names = {
    1491   colspan:   "colSpan",
    1492   rowspan:   "rowSpan",
    1493   valign:    "vAlign",
    1494   datetime:  "dateTime",
    1495   accesskey: "accessKey",
    1496   tabindex:  "tabIndex",
    1497   enctype:   "encType",
    1498   maxlength: "maxLength",
    1499   readonly:  "readOnly",
    1500   longdesc:  "longDesc"
    1501 };
    1502 
    1503 Element._attributeTranslations.values = {
    1504   _getAttr: function(element, attribute) {
    1505     return element.getAttribute(attribute, 2);
    1506   },
    1507 
    1508   _flag: function(element, attribute) {
    1509     return $(element).hasAttribute(attribute) ? attribute : null;
    1510   },
    1511 
    1512   style: function(element) {
    1513     return element.style.cssText.toLowerCase();
    1514   },
    1515 
    1516   title: function(element) {
    1517     var node = element.getAttributeNode('title');
    1518     return node.specified ? node.nodeValue : null;
    1519   }
    1520 };
    1521 
    1522 Object.extend(Element._attributeTranslations.values, {
    1523   href: Element._attributeTranslations.values._getAttr,
    1524   src:  Element._attributeTranslations.values._getAttr,
    1525   disabled: Element._attributeTranslations.values._flag,
    1526   checked:  Element._attributeTranslations.values._flag,
    1527   readonly: Element._attributeTranslations.values._flag,
    1528   multiple: Element._attributeTranslations.values._flag
     1679Object.extend(Element.Methods, {
     1680  childOf: Element.Methods.descendantOf,
     1681  childElements: Element.Methods.immediateDescendants
    15291682});
    15301683
    1531 Element.Methods.Simulated = {
    1532   hasAttribute: function(element, attribute) {
    1533     var t = Element._attributeTranslations;
    1534     attribute = t.names[attribute] || attribute;
    1535     return $(element).getAttributeNode(attribute).specified;
    1536   }
    1537 };
    1538 
    1539 // IE is missing .innerHTML support for TABLE-related elements
    1540 if (document.all && !window.opera){
     1684if (Prototype.Browser.Opera) {
     1685  Element.Methods._getStyle = Element.Methods.getStyle;
     1686  Element.Methods.getStyle = function(element, style) {
     1687    switch(style) {
     1688      case 'left':
     1689      case 'top':
     1690      case 'right':
     1691      case 'bottom':
     1692        if (Element._getStyle(element, 'position') == 'static') return null;
     1693      default: return Element._getStyle(element, style);
     1694    }
     1695  };
     1696}
     1697else if (Prototype.Browser.IE) {
     1698  Element.Methods.getStyle = function(element, style) {
     1699    element = $(element);
     1700    style = (style == 'float' || style == 'cssFloat') ? 'styleFloat' : style.camelize();
     1701    var value = element.style[style];
     1702    if (!value && element.currentStyle) value = element.currentStyle[style];
     1703
     1704    if (style == 'opacity') {
     1705      if (value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
     1706        if (value[1]) return parseFloat(value[1]) / 100;
     1707      return 1.0;
     1708    }
     1709
     1710    if (value == 'auto') {
     1711      if ((style == 'width' || style == 'height') && (element.getStyle('display') != 'none'))
     1712        return element['offset'+style.capitalize()] + 'px';
     1713      return null;
     1714    }
     1715    return value;
     1716  };
     1717
     1718  Element.Methods.setOpacity = function(element, value) {
     1719    element = $(element);
     1720    var filter = element.getStyle('filter'), style = element.style;
     1721    if (value == 1 || value === '') {
     1722      style.filter = filter.replace(/alpha\([^\)]*\)/gi,'');
     1723      return element;
     1724    } else if (value < 0.00001) value = 0;
     1725    style.filter = filter.replace(/alpha\([^\)]*\)/gi, '') +
     1726      'alpha(opacity=' + (value * 100) + ')';
     1727    return element;
     1728  };
     1729
     1730  // IE is missing .innerHTML support for TABLE-related elements
    15411731  Element.Methods.update = function(element, html) {
    15421732    element = $(element);
     
    15591749          depth = 4;
    15601750      }
    1561       $A(element.childNodes).each(function(node){
    1562         element.removeChild(node)
    1563       });
    1564       depth.times(function(){ div = div.firstChild });
    1565 
    1566       $A(div.childNodes).each(
    1567         function(node){ element.appendChild(node) });
     1751      $A(element.childNodes).each(function(node) { element.removeChild(node) });
     1752      depth.times(function() { div = div.firstChild });
     1753      $A(div.childNodes).each(function(node) { element.appendChild(node) });
    15681754    } else {
    15691755      element.innerHTML = html.stripScripts();
    15701756    }
    1571     setTimeout(function() {html.evalScripts()}, 10);
     1757    setTimeout(function() { html.evalScripts() }, 10);
    15721758    return element;
    15731759  }
     1760}
     1761else if (Prototype.Browser.Gecko) {
     1762  Element.Methods.setOpacity = function(element, value) {
     1763    element = $(element);
     1764    element.style.opacity = (value == 1) ? 0.999999 :
     1765      (value === '') ? '' : (value < 0.00001) ? 0 : value;
     1766    return element;
     1767  };
     1768}
     1769
     1770Element._attributeTranslations = {
     1771  names: {
     1772    colspan:   "colSpan",
     1773    rowspan:   "rowSpan",
     1774    valign:    "vAlign",
     1775    datetime:  "dateTime",
     1776    accesskey: "accessKey",
     1777    tabindex:  "tabIndex",
     1778    enctype:   "encType",
     1779    maxlength: "maxLength",
     1780    readonly:  "readOnly",
     1781    longdesc:  "longDesc"
     1782  },
     1783  values: {
     1784    _getAttr: function(element, attribute) {
     1785      return element.getAttribute(attribute, 2);
     1786    },
     1787    _flag: function(element, attribute) {
     1788      return $(element).hasAttribute(attribute) ? attribute : null;
     1789    },
     1790    style: function(element) {
     1791      return element.style.cssText.toLowerCase();
     1792    },
     1793    title: function(element) {
     1794      var node = element.getAttributeNode('title');
     1795      return node.specified ? node.nodeValue : null;
     1796    }
     1797  }
    15741798};
    15751799
     1800(function() {
     1801  Object.extend(this, {
     1802    href: this._getAttr,
     1803    src:  this._getAttr,
     1804    type: this._getAttr,
     1805    disabled: this._flag,
     1806    checked:  this._flag,
     1807    readonly: this._flag,
     1808    multiple: this._flag
     1809  });
     1810}).call(Element._attributeTranslations.values);
     1811
     1812Element.Methods.Simulated = {
     1813  hasAttribute: function(element, attribute) {
     1814    var t = Element._attributeTranslations, node;
     1815    attribute = t.names[attribute] || attribute;
     1816    node = $(element).getAttributeNode(attribute);
     1817    return node && node.specified;
     1818  }
     1819};
     1820
     1821Element.Methods.ByTag = {};
     1822
    15761823Object.extend(Element, Element.Methods);
    15771824
    1578 var _nativeExtensions = false;
    1579 
    1580 if(/Konqueror|Safari|KHTML/.test(navigator.userAgent))
    1581   ['', 'Form', 'Input', 'TextArea', 'Select'].each(function(tag) {
    1582     var className = 'HTML' + tag + 'Element';
    1583     if(window[className]) return;
    1584     var klass = window[className] = {};
    1585     klass.prototype = document.createElement(tag ? tag.toLowerCase() : 'div').__proto__;
    1586   });
     1825if (!Prototype.BrowserFeatures.ElementExtensions &&
     1826 document.createElement('div').__proto__) {
     1827  window.HTMLElement = {};
     1828  window.HTMLElement.prototype = document.createElement('div').__proto__;
     1829  Prototype.BrowserFeatures.ElementExtensions = true;
     1830}
     1831
     1832Element.hasAttribute = function(element, attribute) {
     1833  if (element.hasAttribute) return element.hasAttribute(attribute);
     1834  return Element.Methods.Simulated.hasAttribute(element, attribute);
     1835};
    15871836
    15881837Element.addMethods = function(methods) {
    1589   Object.extend(Element.Methods, methods || {});
     1838  var F = Prototype.BrowserFeatures, T = Element.Methods.ByTag;
     1839
     1840  if (!methods) {
     1841    Object.extend(Form, Form.Methods);
     1842    Object.extend(Form.Element, Form.Element.Methods);
     1843    Object.extend(Element.Methods.ByTag, {
     1844      "FORM":     Object.clone(Form.Methods),
     1845      "INPUT":    Object.clone(Form.Element.Methods),
     1846      "SELECT":   Object.clone(Form.Element.Methods),
     1847      "TEXTAREA": Object.clone(Form.Element.Methods)
     1848    });
     1849  }
     1850
     1851  if (arguments.length == 2) {
     1852    var tagName = methods;
     1853    methods = arguments[1];
     1854  }
     1855
     1856  if (!tagName) Object.extend(Element.Methods, methods || {});
     1857  else {
     1858    if (tagName.constructor == Array) tagName.each(extend);
     1859    else extend(tagName);
     1860  }
     1861
     1862  function extend(tagName) {
     1863    tagName = tagName.toUpperCase();
     1864    if (!Element.Methods.ByTag[tagName])
     1865      Element.Methods.ByTag[tagName] = {};
     1866    Object.extend(Element.Methods.ByTag[tagName], methods);
     1867  }
    15901868
    15911869  function copy(methods, destination, onlyIfAbsent) {
     
    15991877  }
    16001878
    1601   if (typeof HTMLElement != 'undefined') {
     1879  function findDOMClass(tagName) {
     1880    var klass;
     1881    var trans = {
     1882      "OPTGROUP": "OptGroup", "TEXTAREA": "TextArea", "P": "Paragraph",
     1883      "FIELDSET": "FieldSet", "UL": "UList", "OL": "OList", "DL": "DList",
     1884      "DIR": "Directory", "H1": "Heading", "H2": "Heading", "H3": "Heading",
     1885      "H4": "Heading", "H5": "Heading", "H6": "Heading", "Q": "Quote",
     1886      "INS": "Mod", "DEL": "Mod", "A": "Anchor", "IMG": "Image", "CAPTION":
     1887      "TableCaption", "COL": "TableCol", "COLGROUP": "TableCol", "THEAD":
     1888      "TableSection", "TFOOT": "TableSection", "TBODY": "TableSection", "TR":
     1889      "TableRow", "TH": "TableCell", "TD": "TableCell", "FRAMESET":
     1890      "FrameSet", "IFRAME": "IFrame"
     1891    };
     1892    if (trans[tagName]) klass = 'HTML' + trans[tagName] + 'Element';
     1893    if (window[klass]) return window[klass];
     1894    klass = 'HTML' + tagName + 'Element';
     1895    if (window[klass]) return window[klass];
     1896    klass = 'HTML' + tagName.capitalize() + 'Element';
     1897    if (window[klass]) return window[klass];
     1898
     1899    window[klass] = {};
     1900    window[klass].prototype = document.createElement(tagName).__proto__;
     1901    return window[klass];
     1902  }
     1903
     1904  if (F.ElementExtensions) {
    16021905    copy(Element.Methods, HTMLElement.prototype);
    16031906    copy(Element.Methods.Simulated, HTMLElement.prototype, true);
    1604     copy(Form.Methods, HTMLFormElement.prototype);
    1605     [HTMLInputElement, HTMLTextAreaElement, HTMLSelectElement].each(function(klass) {
    1606       copy(Form.Element.Methods, klass.prototype);
    1607     });
    1608     _nativeExtensions = true;
    1609   }
    1610 }
    1611 
    1612 var Toggle = new Object();
    1613 Toggle.display = Element.toggle;
     1907  }
     1908
     1909  if (F.SpecificElementExtensions) {
     1910    for (var tag in Element.Methods.ByTag) {
     1911      var klass = findDOMClass(tag);
     1912      if (typeof klass == "undefined") continue;
     1913      copy(T[tag], klass.prototype);
     1914    }
     1915  }
     1916
     1917  Object.extend(Element, Element.Methods);
     1918  delete Element.ByTag;
     1919};
     1920
     1921var Toggle = { display: Element.toggle };
    16141922
    16151923/*--------------------------------------------------------------------------*/
     
    17422050
    17432051Object.extend(Element.ClassNames.prototype, Enumerable);
     2052/* Portions of the Selector class are derived from Jack Slocum’s DomQuery,
     2053 * part of YUI-Ext version 0.40, distributed under the terms of an MIT-style
     2054 * license.  Please see http://www.yui-ext.com/ for more information. */
     2055
    17442056var Selector = Class.create();
     2057
    17452058Selector.prototype = {
    17462059  initialize: function(expression) {
    1747     this.params = {classNames: []};
    1748     this.expression = expression.toString().strip();
    1749     this.parseExpression();
     2060    this.expression = expression.strip();
    17502061    this.compileMatcher();
    17512062  },
    17522063
    1753   parseExpression: function() {
    1754     function abort(message) { throw 'Parse error in selector: ' + message; }
    1755 
    1756     if (this.expression == '')  abort('empty expression');
    1757 
    1758     var params = this.params, expr = this.expression, match, modifier, clause, rest;
    1759     while (match = expr.match(/^(.*)\[([a-z0-9_:-]+?)(?:([~\|!]?=)(?:"([^"]*)"|([^\]\s]*)))?\]$/i)) {
    1760       params.attributes = params.attributes || [];
    1761       params.attributes.push({name: match[2], operator: match[3], value: match[4] || match[5] || ''});
    1762       expr = match[1];
    1763     }
    1764 
    1765     if (expr == '*') return this.params.wildcard = true;
    1766 
    1767     while (match = expr.match(/^([^a-z0-9_-])?([a-z0-9_-]+)(.*)/i)) {
    1768       modifier = match[1], clause = match[2], rest = match[3];
    1769       switch (modifier) {
    1770         case '#':       params.id = clause; break;
    1771         case '.':       params.classNames.push(clause); break;
    1772         case '':
    1773         case undefined: params.tagName = clause.toUpperCase(); break;
    1774         default:        abort(expr.inspect());
     2064  compileMatcher: function() {
     2065    // Selectors with namespaced attributes can't use the XPath version
     2066    if (Prototype.BrowserFeatures.XPath && !(/\[[\w-]*?:/).test(this.expression))
     2067      return this.compileXPathMatcher();
     2068
     2069    var e = this.expression, ps = Selector.patterns, h = Selector.handlers,
     2070        c = Selector.criteria, le, p, m;
     2071
     2072    if (Selector._cache[e]) {
     2073      this.matcher = Selector._cache[e]; return;
     2074    }
     2075    this.matcher = ["this.matcher = function(root) {",
     2076                    "var r = root, h = Selector.handlers, c = false, n;"];
     2077
     2078    while (e && le != e && (/\S/).test(e)) {
     2079      le = e;
     2080      for (var i in ps) {
     2081        p = ps[i];
     2082        if (m = e.match(p)) {
     2083          this.matcher.push(typeof c[i] == 'function' ? c[i](m) :
     2084              new Template(c[i]).evaluate(m));
     2085          e = e.replace(m[0], '');
     2086          break;
     2087        }
    17752088      }
    1776       expr = rest;
    1777     }
    1778 
    1779     if (expr.length > 0) abort(expr.inspect());
    1780   },
    1781 
    1782   buildMatchExpression: function() {
    1783     var params = this.params, conditions = [], clause;
    1784 
    1785     if (params.wildcard)
    1786       conditions.push('true');
    1787     if (clause = params.id)
    1788       conditions.push('element.readAttribute("id") == ' + clause.inspect());
    1789     if (clause = params.tagName)
    1790       conditions.push('element.tagName.toUpperCase() == ' + clause.inspect());
    1791     if ((clause = params.classNames).length > 0)
    1792       for (var i = 0, length = clause.length; i < length; i++)
    1793         conditions.push('element.hasClassName(' + clause[i].inspect() + ')');
    1794     if (clause = params.attributes) {
    1795       clause.each(function(attribute) {
    1796         var value = 'element.readAttribute(' + attribute.name.inspect() + ')';
    1797         var splitValueBy = function(delimiter) {
    1798           return value + ' && ' + value + '.split(' + delimiter.inspect() + ')';
     2089    }
     2090
     2091    this.matcher.push("return h.unique(n);\n}");
     2092    eval(this.matcher.join('\n'));
     2093    Selector._cache[this.expression] = this.matcher;
     2094  },
     2095
     2096  compileXPathMatcher: function() {
     2097    var e = this.expression, ps = Selector.patterns,
     2098        x = Selector.xpath, le,  m;
     2099
     2100    if (Selector._cache[e]) {
     2101      this.xpath = Selector._cache[e]; return;
     2102    }
     2103
     2104    this.matcher = ['.//*'];
     2105    while (e && le != e && (/\S/).test(e)) {
     2106      le = e;
     2107      for (var i in ps) {
     2108        if (m = e.match(ps[i])) {
     2109          this.matcher.push(typeof x[i] == 'function' ? x[i](m) :
     2110            new Template(x[i]).evaluate(m));
     2111          e = e.replace(m[0], '');
     2112          break;
    17992113        }
    1800 
    1801         switch (attribute.operator) {
    1802           case '=':       conditions.push(value + ' == ' + attribute.value.inspect()); break;
    1803           case '~=':      conditions.push(splitValueBy(' ') + '.include(' + attribute.value.inspect() + ')'); break;
    1804           case '|=':      conditions.push(
    1805                             splitValueBy('-') + '.first().toUpperCase() == ' + attribute.value.toUpperCase().inspect()
    1806                           ); break;
    1807           case '!=':      conditions.push(value + ' != ' + attribute.value.inspect()); break;
    1808           case '':
    1809           case undefined: conditions.push('element.hasAttribute(' + attribute.name.inspect() + ')'); break;
    1810           default:        throw 'Unknown operator ' + attribute.operator + ' in selector';
    1811         }
    1812       });
    1813     }
    1814 
    1815     return conditions.join(' && ');
    1816   },
    1817 
    1818   compileMatcher: function() {
    1819     this.match = new Function('element', 'if (!element.tagName) return false; \
    1820       element = $(element); \
    1821       return ' + this.buildMatchExpression());
    1822   },
    1823 
    1824   findElements: function(scope) {
    1825     var element;
    1826 
    1827     if (element = $(this.params.id))
    1828       if (this.match(element))
    1829         if (!scope || Element.childOf(element, scope))
    1830           return [element];
    1831 
    1832     scope = (scope || document).getElementsByTagName(this.params.tagName || '*');
    1833 
    1834     var results = [];
    1835     for (var i = 0, length = scope.length; i < length; i++)
    1836       if (this.match(element = scope[i]))
    1837         results.push(Element.extend(element));
    1838 
    1839     return results;
     2114      }
     2115    }
     2116
     2117    this.xpath = this.matcher.join('');
     2118    Selector._cache[this.expression] = this.xpath;
     2119  },
     2120
     2121  findElements: function(root) {
     2122    root = root || document;
     2123    if (this.xpath) return document._getElementsByXPath(this.xpath, root);
     2124    return this.matcher(root);
     2125  },
     2126
     2127  match: function(element) {
     2128    return this.findElements(document).include(element);
    18402129  },
    18412130
    18422131  toString: function() {
    18432132    return this.expression;
    1844   }
    1845 }
     2133  },
     2134
     2135  inspect: function() {
     2136    return "#<Selector:" + this.expression.inspect() + ">";
     2137  }
     2138};
    18462139
    18472140Object.extend(Selector, {
     2141  _cache: {},
     2142
     2143  xpath: {
     2144    descendant:   "//*",
     2145    child:        "/*",
     2146    adjacent:     "/following-sibling::*[1]",
     2147    laterSibling: '/following-sibling::*',
     2148    tagName:      function(m) {
     2149      if (m[1] == '*') return '';
     2150      return "[local-name()='" + m[1].toLowerCase() +
     2151             "' or local-name()='" + m[1].toUpperCase() + "']";
     2152    },
     2153    className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
     2154    id:           "[@id='#{1}']",
     2155    attrPresence: "[@#{1}]",
     2156    attr: function(m) {
     2157      m[3] = m[5] || m[6];
     2158      return new Template(Selector.xpath.operators[m[2]]).evaluate(m);
     2159    },
     2160    pseudo: function(m) {
     2161      var h = Selector.xpath.pseudos[m[1]];
     2162      if (!h) return '';
     2163      if (typeof h === 'function') return h(m);
     2164      return new Template(Selector.xpath.pseudos[m[1]]).evaluate(m);
     2165    },
     2166    operators: {
     2167      '=':  "[@#{1}='#{3}']",
     2168      '!=': "[@#{1}!='#{3}']",
     2169      '^=': "[starts-with(@#{1}, '#{3}')]",
     2170      '$=': "[substring(@#{1}, (string-length(@#{1}) - string-length('#{3}') + 1))='#{3}']",
     2171      '*=': "[contains(@#{1}, '#{3}')]",
     2172      '~=': "[contains(concat(' ', @#{1}, ' '), ' #{3} ')]",
     2173      '|=': "[contains(concat('-', @#{1}, '-'), '-#{3}-')]"
     2174    },
     2175    pseudos: {
     2176      'first-child': '[not(preceding-sibling::*)]',
     2177      'last-child':  '[not(following-sibling::*)]',
     2178      'only-child':  '[not(preceding-sibling::* or following-sibling::*)]',
     2179      'empty':       "[count(*) = 0 and (count(text()) = 0 or translate(text(), ' \t\r\n', '') = '')]",
     2180      'checked':     "[@checked]",
     2181      'disabled':    "[@disabled]",
     2182      'enabled':     "[not(@disabled)]",
     2183      'not': function(m) {
     2184        var e = m[6], p = Selector.patterns,
     2185            x = Selector.xpath, le, m, v;
     2186
     2187        var exclusion = [];
     2188        while (e && le != e && (/\S/).test(e)) {
     2189          le = e;
     2190          for (var i in p) {
     2191            if (m = e.match(p[i])) {
     2192              v = typeof x[i] == 'function' ? x[i](m) : new Template(x[i]).evaluate(m);
     2193              exclusion.push("(" + v.substring(1, v.length - 1) + ")");
     2194              e = e.replace(m[0], '');
     2195              break;
     2196            }
     2197          }
     2198        }
     2199        return "[not(" + exclusion.join(" and ") + ")]";
     2200      },
     2201      'nth-child':      function(m) {
     2202        return Selector.xpath.pseudos.nth("(count(./preceding-sibling::*) + 1) ", m);
     2203      },
     2204      'nth-last-child': function(m) {
     2205        return Selector.xpath.pseudos.nth("(count(./following-sibling::*) + 1) ", m);
     2206      },
     2207      'nth-of-type':    function(m) {
     2208        return Selector.xpath.pseudos.nth("position() ", m);
     2209      },
     2210      'nth-last-of-type': function(m) {
     2211        return Selector.xpath.pseudos.nth("(last() + 1 - position()) ", m);
     2212      },
     2213      'first-of-type':  function(m) {
     2214        m[6] = "1"; return Selector.xpath.pseudos['nth-of-type'](m);
     2215      },
     2216      'last-of-type':   function(m) {
     2217        m[6] = "1"; return Selector.xpath.pseudos['nth-last-of-type'](m);
     2218      },
     2219      'only-of-type':   function(m) {
     2220        var p = Selector.xpath.pseudos; return p['first-of-type'](m) + p['last-of-type'](m);
     2221      },
     2222      nth: function(fragment, m) {
     2223        var mm, formula = m[6], predicate;
     2224        if (formula == 'even') formula = '2n+0';
     2225        if (formula == 'odd')  formula = '2n+1';
     2226        if (mm = formula.match(/^(\d+)$/)) // digit only
     2227          return '[' + fragment + "= " + mm[1] + ']';
     2228        if (mm = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
     2229          if (mm[1] == "-") mm[1] = -1;
     2230          var a = mm[1] ? Number(mm[1]) : 1;
     2231          var b = mm[2] ? Number(mm[2]) : 0;
     2232          predicate = "[((#{fragment} - #{b}) mod #{a} = 0) and " +
     2233          "((#{fragment} - #{b}) div #{a} >= 0)]";
     2234          return new Template(predicate).evaluate({
     2235            fragment: fragment, a: a, b: b });
     2236        }
     2237      }
     2238    }
     2239  },
     2240
     2241  criteria: {
     2242    tagName:      'n = h.tagName(n, r, "#{1}", c);   c = false;',
     2243    className:    'n = h.className(n, r, "#{1}", c); c = false;',
     2244    id:           'n = h.id(n, r, "#{1}", c);        c = false;',
     2245    attrPresence: 'n = h.attrPresence(n, r, "#{1}"); c = false;',
     2246    attr: function(m) {
     2247      m[3] = (m[5] || m[6]);
     2248      return new Template('n = h.attr(n, r, "#{1}", "#{3}", "#{2}"); c = false;').evaluate(m);
     2249    },
     2250    pseudo:       function(m) {
     2251      if (m[6]) m[6] = m[6].replace(/"/g, '\\"');
     2252      return new Template('n = h.pseudo(n, "#{1}", "#{6}", r, c); c = false;').evaluate(m);
     2253    },
     2254    descendant:   'c = "descendant";',
     2255    child:        'c = "child";',
     2256    adjacent:     'c = "adjacent";',
     2257    laterSibling: 'c = "laterSibling";'
     2258  },
     2259
     2260  patterns: {
     2261    // combinators must be listed first
     2262    // (and descendant needs to be last combinator)
     2263    laterSibling: /^\s*~\s*/,
     2264    child:        /^\s*>\s*/,
     2265    adjacent:     /^\s*\+\s*/,
     2266    descendant:   /^\s/,
     2267
     2268    // selectors follow
     2269    tagName:      /^\s*(\*|[\w\-]+)(\b|$)?/,
     2270    id:           /^#([\w\-\*]+)(\b|$)/,
     2271    className:    /^\.([\w\-\*]+)(\b|$)/,
     2272    pseudo:       /^:((first|last|nth|nth-last|only)(-child|-of-type)|empty|checked|(en|dis)abled|not)(\((.*?)\))?(\b|$|\s|(?=:))/,
     2273    attrPresence: /^\[([\w]+)\]/,
     2274    attr:         /\[((?:[\w-]*:)?[\w-]+)\s*(?:([!^$*~|]?=)\s*((['"])([^\]]*?)\4|([^'"][^\]]*?)))?\]/
     2275  },
     2276
     2277  handlers: {
     2278    // UTILITY FUNCTIONS
     2279    // joins two collections
     2280    concat: function(a, b) {
     2281      for (var i = 0, node; node = b[i]; i++)
     2282        a.push(node);
     2283      return a;
     2284    },
     2285
     2286    // marks an array of nodes for counting
     2287    mark: function(nodes) {
     2288      for (var i = 0, node; node = nodes[i]; i++)
     2289        node._counted = true;
     2290      return nodes;
     2291    },
     2292
     2293    unmark: function(nodes) {
     2294      for (var i = 0, node; node = nodes[i]; i++)
     2295        node._counted = undefined;
     2296      return nodes;
     2297    },
     2298
     2299    // mark each child node with its position (for nth calls)
     2300    // "ofType" flag indicates whether we're indexing for nth-of-type
     2301    // rather than nth-child
     2302    index: function(parentNode, reverse, ofType) {
     2303      parentNode._counted = true;
     2304      if (reverse) {
     2305        for (var nodes = parentNode.childNodes, i = nodes.length - 1, j = 1; i >= 0; i--) {
     2306          node = nodes[i];
     2307          if (node.nodeType == 1 && (!ofType || node._counted)) node.nodeIndex = j++;
     2308        }
     2309      } else {
     2310        for (var i = 0, j = 1, nodes = parentNode.childNodes; node = nodes[i]; i++)
     2311          if (node.nodeType == 1 && (!ofType || node._counted)) node.nodeIndex = j++;
     2312      }
     2313    },
     2314
     2315    // filters out duplicates and extends all nodes
     2316    unique: function(nodes) {
     2317      if (nodes.length == 0) return nodes;
     2318      var results = [], n;
     2319      for (var i = 0, l = nodes.length; i < l; i++)
     2320        if (!(n = nodes[i])._counted) {
     2321          n._counted = true;
     2322          results.push(Element.extend(n));
     2323        }
     2324      return Selector.handlers.unmark(results);
     2325    },
     2326
     2327    // COMBINATOR FUNCTIONS
     2328    descendant: function(nodes) {
     2329      var h = Selector.handlers;
     2330      for (var i = 0, results = [], node; node = nodes[i]; i++)
     2331        h.concat(results, node.getElementsByTagName('*'));
     2332      return results;
     2333    },
     2334
     2335    child: function(nodes) {
     2336      var h = Selector.handlers;
     2337      for (var i = 0, results = [], node; node = nodes[i]; i++) {
     2338        for (var j = 0, children = [], child; child = node.childNodes[j]; j++)
     2339          if (child.nodeType == 1 && child.tagName != '!') results.push(child);
     2340      }
     2341      return results;
     2342    },
     2343
     2344    adjacent: function(nodes) {
     2345      for (var i = 0, results = [], node; node = nodes[i]; i++) {
     2346        var next = this.nextElementSibling(node);
     2347        if (next) results.push(next);
     2348      }
     2349      return results;
     2350    },
     2351
     2352    laterSibling: function(nodes) {
     2353      var h = Selector.handlers;
     2354      for (var i = 0, results = [], node; node = nodes[i]; i++)
     2355        h.concat(results, Element.nextSiblings(node));
     2356      return results;
     2357    },
     2358
     2359    nextElementSibling: function(node) {
     2360      while (node = node.nextSibling)
     2361          if (node.nodeType == 1) return node;
     2362      return null;
     2363    },
     2364
     2365    previousElementSibling: function(node) {
     2366      while (node = node.previousSibling)
     2367        if (node.nodeType == 1) return node;
     2368      return null;
     2369    },
     2370
     2371    // TOKEN FUNCTIONS
     2372    tagName: function(nodes, root, tagName, combinator) {
     2373      tagName = tagName.toUpperCase();
     2374      var results = [], h = Selector.handlers;
     2375      if (nodes) {
     2376        if (combinator) {
     2377          // fastlane for ordinary descendant combinators
     2378          if (combinator == "descendant") {
     2379            for (var i = 0, node; node = nodes[i]; i++)
     2380              h.concat(results, node.getElementsByTagName(tagName));
     2381            return results;
     2382          } else nodes = this[combinator](nodes);
     2383          if (tagName == "*") return nodes;
     2384        }
     2385        for (var i = 0, node; node = nodes[i]; i++)
     2386          if (node.tagName.toUpperCase() == tagName) results.push(node);
     2387        return results;
     2388      } else return root.getElementsByTagName(tagName);
     2389    },
     2390
     2391    id: function(nodes, root, id, combinator) {
     2392      var targetNode = $(id), h = Selector.handlers;
     2393      if (!nodes && root == document) return targetNode ? [targetNode] : [];
     2394      if (nodes) {
     2395        if (combinator) {
     2396          if (combinator == 'child') {
     2397            for (var i = 0, node; node = nodes[i]; i++)
     2398              if (targetNode.parentNode == node) return [targetNode];
     2399          } else if (combinator == 'descendant') {
     2400            for (var i = 0, node; node = nodes[i]; i++)
     2401              if (Element.descendantOf(targetNode, node)) return [targetNode];
     2402          } else if (combinator == 'adjacent') {
     2403            for (var i = 0, node; node = nodes[i]; i++)
     2404              if (Selector.handlers.previousElementSibling(targetNode) == node)
     2405                return [targetNode];
     2406          } else nodes = h[combinator](nodes);
     2407        }
     2408        for (var i = 0, node; node = nodes[i]; i++)
     2409          if (node == targetNode) return [targetNode];
     2410        return [];
     2411      }
     2412      return (targetNode && Element.descendantOf(targetNode, root)) ? [targetNode] : [];
     2413    },
     2414
     2415    className: function(nodes, root, className, combinator) {
     2416      if (nodes && combinator) nodes = this[combinator](nodes);
     2417      return Selector.handlers.byClassName(nodes, root, className);
     2418    },
     2419
     2420    byClassName: function(nodes, root, className) {
     2421      if (!nodes) nodes = Selector.handlers.descendant([root]);
     2422      var needle = ' ' + className + ' ';
     2423      for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
     2424        nodeClassName = node.className;
     2425        if (nodeClassName.length == 0) continue;
     2426        if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
     2427          results.push(node);
     2428      }
     2429      return results;
     2430    },
     2431
     2432    attrPresence: function(nodes, root, attr) {
     2433      var results = [];
     2434      for (var i = 0, node; node = nodes[i]; i++)
     2435        if (Element.hasAttribute(node, attr)) results.push(node);
     2436      return results;
     2437    },
     2438
     2439    attr: function(nodes, root, attr, value, operator) {
     2440      if (!nodes) nodes = root.getElementsByTagName("*");
     2441      var handler = Selector.operators[operator], results = [];
     2442      for (var i = 0, node; node = nodes[i]; i++) {
     2443        var nodeValue = Element.readAttribute(node, attr);
     2444        if (nodeValue === null) continue;
     2445        if (handler(nodeValue, value)) results.push(node);
     2446      }
     2447      return results;
     2448    },
     2449
     2450    pseudo: function(nodes, name, value, root, combinator) {
     2451      if (nodes && combinator) nodes = this[combinator](nodes);
     2452      if (!nodes) nodes = root.getElementsByTagName("*");
     2453      return Selector.pseudos[name](nodes, value, root);
     2454    }
     2455  },
     2456
     2457  pseudos: {
     2458    'first-child': function(nodes, value, root) {
     2459      for (var i = 0, results = [], node; node = nodes[i]; i++) {
     2460        if (Selector.handlers.previousElementSibling(node)) continue;
     2461          results.push(node);
     2462      }
     2463      return results;
     2464    },
     2465    'last-child': function(nodes, value, root) {
     2466      for (var i = 0, results = [], node; node = nodes[i]; i++) {
     2467        if (Selector.handlers.nextElementSibling(node)) continue;
     2468          results.push(node);
     2469      }
     2470      return results;
     2471    },
     2472    'only-child': function(nodes, value, root) {
     2473      var h = Selector.handlers;
     2474      for (var i = 0, results = [], node; node = nodes[i]; i++)
     2475        if (!h.previousElementSibling(node) && !h.nextElementSibling(node))
     2476          results.push(node);
     2477      return results;
     2478    },
     2479    'nth-child':        function(nodes, formula, root) {
     2480      return Selector.pseudos.nth(nodes, formula, root);
     2481    },
     2482    'nth-last-child':   function(nodes, formula, root) {
     2483      return Selector.pseudos.nth(nodes, formula, root, true);
     2484    },
     2485    'nth-of-type':      function(nodes, formula, root) {
     2486      return Selector.pseudos.nth(nodes, formula, root, false, true);
     2487    },
     2488    'nth-last-of-type': function(nodes, formula, root) {
     2489      return Selector.pseudos.nth(nodes, formula, root, true, true);
     2490    },
     2491    'first-of-type':    function(nodes, formula, root) {
     2492      return Selector.pseudos.nth(nodes, "1", root, false, true);
     2493    },
     2494    'last-of-type':     function(nodes, formula, root) {
     2495      return Selector.pseudos.nth(nodes, "1", root, true, true);
     2496    },
     2497    'only-of-type':     function(nodes, formula, root) {
     2498      var p = Selector.pseudos;
     2499      return p['last-of-type'](p['first-of-type'](nodes, formula, root), formula, root);
     2500    },
     2501
     2502    // handles the an+b logic
     2503    getIndices: function(a, b, total) {
     2504      if (a == 0) return b > 0 ? [b] : [];
     2505      return $R(1, total).inject([], function(memo, i) {
     2506        if (0 == (i - b) % a && (i - b) / a >= 0) memo.push(i);
     2507        return memo;
     2508      });
     2509    },
     2510
     2511    // handles nth(-last)-child, nth(-last)-of-type, and (first|last)-of-type
     2512    nth: function(nodes, formula, root, reverse, ofType) {
     2513      if (nodes.length == 0) return [];
     2514      if (formula == 'even') formula = '2n+0';
     2515      if (formula == 'odd')  formula = '2n+1';
     2516      var h = Selector.handlers, results = [], indexed = [], m;
     2517      h.mark(nodes);
     2518      for (var i = 0, node; node = nodes[i]; i++) {
     2519        if (!node.parentNode._counted) {
     2520          h.index(node.parentNode, reverse, ofType);
     2521          indexed.push(node.parentNode);
     2522        }
     2523      }
     2524      if (formula.match(/^\d+$/)) { // just a number
     2525        formula = Number(formula);
     2526        for (var i = 0, node; node = nodes[i]; i++)
     2527          if (node.nodeIndex == formula) results.push(node);
     2528      } else if (m = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
     2529        if (m[1] == "-") m[1] = -1;
     2530        var a = m[1] ? Number(m[1]) : 1;
     2531        var b = m[2] ? Number(m[2]) : 0;
     2532        var indices = Selector.pseudos.getIndices(a, b, nodes.length);
     2533        for (var i = 0, node, l = indices.length; node = nodes[i]; i++) {
     2534          for (var j = 0; j < l; j++)
     2535            if (node.nodeIndex == indices[j]) results.push(node);
     2536        }
     2537      }
     2538      h.unmark(nodes);
     2539      h.unmark(indexed);
     2540      return results;
     2541    },
     2542
     2543    'empty': function(nodes, value, root) {
     2544      for (var i = 0, results = [], node; node = nodes[i]; i++) {
     2545        // IE treats comments as element nodes
     2546        if (node.tagName == '!' || (node.firstChild && !node.innerHTML.match(/^\s*$/))) continue;
     2547        results.push(node);
     2548      }
     2549      return results;
     2550    },
     2551
     2552    'not': function(nodes, selector, root) {
     2553      var h = Selector.handlers, selectorType, m;
     2554      var exclusions = new Selector(selector).findElements(root);
     2555      h.mark(exclusions);
     2556      for (var i = 0, results = [], node; node = nodes[i]; i++)
     2557        if (!node._counted) results.push(node);
     2558      h.unmark(exclusions);
     2559      return results;
     2560    },
     2561
     2562    'enabled': function(nodes, value, root) {
     2563      for (var i = 0, results = [], node; node = nodes[i]; i++)
     2564        if (!node.disabled) results.push(node);
     2565      return results;
     2566    },
     2567
     2568    'disabled': function(nodes, value, root) {
     2569      for (var i = 0, results = [], node; node = nodes[i]; i++)
     2570        if (node.disabled) results.push(node);
     2571      return results;
     2572    },
     2573
     2574    'checked': function(nodes, value, root) {
     2575      for (var i = 0, results = [], node; node = nodes[i]; i++)
     2576        if (node.checked) results.push(node);
     2577      return results;
     2578    }
     2579  },
     2580
     2581  operators: {
     2582    '=':  function(nv, v) { return nv == v; },
     2583    '!=': function(nv, v) { return nv != v; },
     2584    '^=': function(nv, v) { return nv.startsWith(v); },
     2585    '$=': function(nv, v) { return nv.endsWith(v); },
     2586    '*=': function(nv, v) { return nv.include(v); },
     2587    '~=': function(nv, v) { return (' ' + nv + ' ').include(' ' + v + ' '); },
     2588    '|=': function(nv, v) { return ('-' + nv.toUpperCase() + '-').include('-' + v.toUpperCase() + '-'); }
     2589  },
     2590
    18482591  matchElements: function(elements, expression) {
    1849     var selector = new Selector(expression);
    1850     return elements.select(selector.match.bind(selector)).map(Element.extend);
     2592    var matches = new Selector(expression).findElements(), h = Selector.handlers;
     2593    h.mark(matches);
     2594    for (var i = 0, results = [], element; element = elements[i]; i++)
     2595      if (element._counted) results.push(element);
     2596    h.unmark(matches);
     2597    return results;
    18512598  },
    18522599
    18532600  findElement: function(elements, expression, index) {
    1854     if (typeof expression == 'number') index = expression, expression = false;
     2601    if (typeof expression == 'number') {
     2602      index = expression; expression = false;
     2603    }
    18552604    return Selector.matchElements(elements, expression || '*')[index || 0];
    18562605  },
    18572606
    18582607  findChildElements: function(element, expressions) {
    1859     return expressions.map(function(expression) {
    1860       return expression.match(/[^\s"]+(?:"[^"]*"[^\s"]+)*/g).inject([null], function(results, expr) {
    1861         var selector = new Selector(expr);
    1862         return results.inject([], function(elements, result) {
    1863           return elements.concat(selector.findElements(result || element));
    1864         });
    1865       });
    1866     }).flatten();
     2608    var exprs = expressions.join(','), expressions = [];
     2609    exprs.scan(/(([\w#:.~>+()\s-]+|\*|\[.*?\])+)\s*(,|$)/, function(m) {
     2610      expressions.push(m[1].strip());
     2611    });
     2612    var results = [], h = Selector.handlers;
     2613    for (var i = 0, l = expressions.length, selector; i < l; i++) {
     2614      selector = new Selector(expressions[i].strip());
     2615      h.concat(results, selector.findElements(element));
     2616    }
     2617    return (l > 1) ? h.unique(results) : results;
    18672618  }
    18682619});
     
    18812632      if (!element.disabled && element.name) {
    18822633        var key = element.name, value = $(element).getValue();
    1883         if (value != undefined) {
    1884           if (result[key]) {
     2634        if (value != null) {
     2635            if (key in result) {
    18852636            if (result[key].constructor != Array) result[key] = [result[key]];
    18862637            result[key].push(value);
     
    19292680  disable: function(form) {
    19302681    form = $(form);
    1931     form.getElements().each(function(element) {
    1932       element.blur();
    1933       element.disabled = 'true';
    1934     });
     2682    Form.getElements(form).invoke('disable');
    19352683    return form;
    19362684  },
     
    19382686  enable: function(form) {
    19392687    form = $(form);
    1940     form.getElements().each(function(element) {
    1941       element.disabled = '';
    1942     });
     2688    Form.getElements(form).invoke('enable');
    19432689    return form;
    19442690  },
     
    19552701    form.findFirstElement().activate();
    19562702    return form;
    1957   }
    1958 }
    1959 
    1960 Object.extend(Form, Form.Methods);
     2703  },
     2704
     2705  request: function(form, options) {
     2706    form = $(form), options = Object.clone(options || {});
     2707
     2708    var params = options.parameters;
     2709    options.parameters = form.serialize(true);
     2710
     2711    if (params) {
     2712      if (typeof params == 'string') params = params.toQueryParams();
     2713      Object.extend(options.parameters, params);
     2714    }
     2715
     2716    if (form.hasAttribute('method') && !options.method)
     2717      options.method = form.method;
     2718
     2719    return new Ajax.Request(form.readAttribute('action'), options);
     2720  }
     2721}
    19612722
    19622723/*--------------------------------------------------------------------------*/
     
    20052766  activate: function(element) {
    20062767    element = $(element);
    2007     element.focus();
    2008     if (element.select && ( element.tagName.toLowerCase() != 'input' ||
    2009       !['button', 'reset', 'submit'].include(element.type) ) )
    2010       element.select();
     2768    try {
     2769      element.focus();
     2770      if (element.select && (element.tagName.toLowerCase() != 'input' ||
     2771        !['button', 'reset', 'submit'].include(element.type)))
     2772        element.select();
     2773    } catch (e) {}
    20112774    return element;
    20122775  },
     
    20142777  disable: function(element) {
    20152778    element = $(element);
     2779    element.blur();
    20162780    element.disabled = true;
    20172781    return element;
     
    20202784  enable: function(element) {
    20212785    element = $(element);
    2022     element.blur();
    20232786    element.disabled = false;
    20242787    return element;
     
    20262789}
    20272790
    2028 Object.extend(Form.Element, Form.Element.Methods);
     2791/*--------------------------------------------------------------------------*/
     2792
    20292793var Field = Form.Element;
    2030 var $F = Form.Element.getValue;
     2794var $F = Form.Element.Methods.getValue;
    20312795
    20322796/*--------------------------------------------------------------------------*/
     
    21952959
    21962960  element: function(event) {
    2197     return event.target || event.srcElement;
     2961    return $(event.target || event.srcElement);
    21982962  },
    21992963
     
    22603024
    22613025    if (name == 'keypress' &&
    2262         (navigator.appVersion.match(/Konqueror|Safari|KHTML/)
    2263         || element.attachEvent))
     3026      (Prototype.Browser.WebKit || element.attachEvent))
    22643027      name = 'keydown';
    22653028
     
    22723035
    22733036    if (name == 'keypress' &&
    2274         (navigator.appVersion.match(/Konqueror|Safari|KHTML/)
    2275         || element.detachEvent))
     3037        (Prototype.Browser.WebKit || element.attachEvent))
    22763038      name = 'keydown';
    22773039
     
    22873049
    22883050/* prevent memory leaks in IE */
    2289 if (navigator.appVersion.match(/\bMSIE\b/))
     3051if (Prototype.Browser.IE)
    22903052  Event.observe(window, 'unload', Event.unloadCache, false);
    22913053var Position = {
     
    24013163
    24023164      // Safari fix
    2403       if (element.offsetParent==document.body)
     3165      if (element.offsetParent == document.body)
    24043166        if (Element.getStyle(element,'position')=='absolute') break;
    24053167
     
    24973259// positioned.  For performance reasons, redefine Position.cumulativeOffset for
    24983260// KHTML/WebKit only.
    2499 if (/Konqueror|Safari|KHTML/.test(navigator.userAgent)) {
     3261if (Prototype.Browser.WebKit) {
    25003262  Position.cumulativeOffset = function(element) {
    25013263    var valueT = 0, valueL = 0;
  • trunk/wp-includes/js/scriptaculous/scriptaculous.js

    r5482 r5792  
    1 // script.aculo.us scriptaculous.js v1.7.1_beta2, Sat Apr 28 15:20:12 CEST 2007
     1// script.aculo.us scriptaculous.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007
    22
    33// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
     
    2525
    2626var Scriptaculous = {
    27   Version: '1.7.1_beta2',
     27  Version: '1.7.1_beta3',
    2828  require: function(libraryName) {
    2929    // inserting via DOM fails in Safari 2.0, so brute force approach
  • trunk/wp-includes/js/scriptaculous/slider.js

    r5482 r5792  
    1 // script.aculo.us slider.js v1.7.1_beta2, Sat Apr 28 15:20:12 CEST 2007
     1// script.aculo.us slider.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007
    22
    33// Copyright (c) 2005-2007 Marty Haught, Thomas Fuchs
  • trunk/wp-includes/js/scriptaculous/sound.js

    r5482 r5792  
    1 // script.aculo.us sound.js v1.7.1_beta2, Sat Apr 28 15:20:12 CEST 2007
     1// script.aculo.us sound.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007
    22
    33// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
  • trunk/wp-includes/js/scriptaculous/unittest.js

    r5482 r5792  
    1 // script.aculo.us unittest.js v1.7.1_beta2, Sat Apr 28 15:20:12 CEST 2007
     1// script.aculo.us unittest.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007
    22
    33// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
  • trunk/wp-includes/js/scriptaculous/wp-scriptaculous.js

    r4813 r5792  
    1 // Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
     1// script.aculo.us scriptaculous.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007
     2
     3// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
    24//
    35// Permission is hereby granted, free of charge, to any person obtaining
     
    1113// The above copyright notice and this permission notice shall be
    1214// included in all copies or substantial portions of the Software.
     15//
     16// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
     17// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
     18// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
     19// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
     20// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
     21// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
     22// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
     23//
     24// For details, see the script.aculo.us web site: http://script.aculo.us/
    1325
    1426var Scriptaculous = {
    15   Version: '1.7.0',
     27  Version: '1.7.1_beta3',
    1628  require: function(libraryName) {
    1729    // inserting via DOM fails in Safari 2.0, so brute force approach
    1830    document.write('<script type="text/javascript" src="'+libraryName+'"></script>');
    1931  },
     32  REQUIRED_PROTOTYPE: '1.5.1',
    2033  load: function() {
     34    function convertVersionString(versionString){
     35      var r = versionString.split('.');
     36      return parseInt(r[0])*100000 + parseInt(r[1])*1000 + parseInt(r[2]);
     37    }
     38 
    2139    if((typeof Prototype=='undefined') ||
    2240       (typeof Element == 'undefined') ||
    2341       (typeof Element.Methods=='undefined') ||
    24        parseFloat(Prototype.Version.split(".")[0] + "." +
    25                   Prototype.Version.split(".")[1]) < 1.5)
    26        throw("script.aculo.us requires the Prototype JavaScript framework >= 1.5.0");
     42       (convertVersionString(Prototype.Version) <
     43        convertVersionString(Scriptaculous.REQUIRED_PROTOTYPE)))
     44       throw("script.aculo.us requires the Prototype JavaScript framework >= " +
     45        Scriptaculous.REQUIRED_PROTOTYPE);
    2746   
    2847    $A(document.getElementsByTagName("script")).findAll( function(s) {
     
    3150      var path = s.src.replace(/scriptaculous\.js(\?.*)?$/,'');
    3251      var includes = s.src.match(/\?.*load=([a-z,]*)/);
    33       if ( includes )
    34        includes[1].split(',').each(
     52      (includes ? includes[1] : 'builder,effects,dragdrop,controls,slider,sound').split(',').each(
    3553       function(include) { Scriptaculous.require(path+include+'.js') });
    3654    });
Note: See TracChangeset for help on using the changeset viewer.