git.infodrom.org Git - infodrom/rico3/blob - ricoClient/js/baselibs/prototype.js

   1 /*  Prototype JavaScript framework, version 1.6.1
   2  *  (c) 2005-2009 Sam Stephenson
   3  *
   4  *  Prototype is freely distributable under the terms of an MIT-style license.
   5  *  For details, see the Prototype web site: http://www.prototypejs.org/
   6  *
   7  *--------------------------------------------------------------------------*/
   8
   9 var Prototype = {
  10   Version: '1.6.1',
  11
  12   Browser: (function(){
  13     var ua = navigator.userAgent;
  14     var isOpera = Object.prototype.toString.call(window.opera) == '[object Opera]';
  15     return {
  16       IE:             !!window.attachEvent && !isOpera,
  17       Opera:          isOpera,
  18       WebKit:         ua.indexOf('AppleWebKit/') > -1,
  19       Gecko:          ua.indexOf('Gecko') > -1 && ua.indexOf('KHTML') === -1,
  20       MobileSafari:   /Apple.*Mobile.*Safari/.test(ua)
  21     }
  22   })(),
  23
  24   BrowserFeatures: {
  25     XPath: !!document.evaluate,
  26     SelectorsAPI: !!document.querySelector,
  27     ElementExtensions: (function() {
  28       var constructor = window.Element || window.HTMLElement;
  29       return !!(constructor && constructor.prototype);
  30     })(),
  31     SpecificElementExtensions: (function() {
  32       if (typeof window.HTMLDivElement !== 'undefined')
  33         return true;
  34
  35       var div = document.createElement('div');
  36       var form = document.createElement('form');
  37       var isSupported = false;
  38
  39       if (div['__proto__'] && (div['__proto__'] !== form['__proto__'])) {
  40         isSupported = true;
  41       }
  42
  43       div = form = null;
  44
  45       return isSupported;
  46     })()
  47   },
  48
  49   ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',
  50   JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,
  51
  52   emptyFunction: function() { },
  53   K: function(x) { return x }
  54 };
  55
  56 if (Prototype.Browser.MobileSafari)
  57   Prototype.BrowserFeatures.SpecificElementExtensions = false;
  58
  59
  60 var Abstract = { };
  61
  62
  63 var Try = {
  64   these: function() {
  65     var returnValue;
  66
  67     for (var i = 0, length = arguments.length; i < length; i++) {
  68       var lambda = arguments[i];
  69       try {
  70         returnValue = lambda();
  71         break;
  72       } catch (e) { }
  73     }
  74
  75     return returnValue;
  76   }
  77 };
  78
  79 /* Based on Alex Arnell's inheritance implementation. */
  80
  81 var Class = (function() {
  82   function subclass() {};
  83   function create() {
  84     var parent = null, properties = $A(arguments);
  85     if (Object.isFunction(properties[0]))
  86       parent = properties.shift();
  87
  88     function klass() {
  89       this.initialize.apply(this, arguments);
  90     }
  91
  92     Object.extend(klass, Class.Methods);
  93     klass.superclass = parent;
  94     klass.subclasses = [];
  95
  96     if (parent) {
  97       subclass.prototype = parent.prototype;
  98       klass.prototype = new subclass;
  99       parent.subclasses.push(klass);
 100     }
 101
 102     for (var i = 0; i < properties.length; i++)
 103       klass.addMethods(properties[i]);
 104
 105     if (!klass.prototype.initialize)
 106       klass.prototype.initialize = Prototype.emptyFunction;
 107
 108     klass.prototype.constructor = klass;
 109     return klass;
 110   }
 111
 112   function addMethods(source) {
 113     var ancestor   = this.superclass && this.superclass.prototype;
 114     var properties = Object.keys(source);
 115
 116     if (!Object.keys({ toString: true }).length) {
 117       if (source.toString != Object.prototype.toString)
 118         properties.push("toString");
 119       if (source.valueOf != Object.prototype.valueOf)
 120         properties.push("valueOf");
 121     }
 122
 123     for (var i = 0, length = properties.length; i < length; i++) {
 124       var property = properties[i], value = source[property];
 125       if (ancestor && Object.isFunction(value) &&
 126           value.argumentNames().first() == "$super") {
 127         var method = value;
 128         value = (function(m) {
 129           return function() { return ancestor[m].apply(this, arguments); };
 130         })(property).wrap(method);
 131
 132         value.valueOf = method.valueOf.bind(method);
 133         value.toString = method.toString.bind(method);
 134       }
 135       this.prototype[property] = value;
 136     }
 137
 138     return this;
 139   }
 140
 141   return {
 142     create: create,
 143     Methods: {
 144       addMethods: addMethods
 145     }
 146   };
 147 })();
 148 (function() {
 149
 150   var _toString = Object.prototype.toString;
 151
 152   function extend(destination, source) {
 153     for (var property in source)
 154       destination[property] = source[property];
 155     return destination;
 156   }
 157
 158   function inspect(object) {
 159     try {
 160       if (isUndefined(object)) return 'undefined';
 161       if (object === null) return 'null';
 162       return object.inspect ? object.inspect() : String(object);
 163     } catch (e) {
 164       if (e instanceof RangeError) return '...';
 165       throw e;
 166     }
 167   }
 168
 169   function toJSON(object) {
 170     var type = typeof object;
 171     switch (type) {
 172       case 'undefined':
 173       case 'function':
 174       case 'unknown': return;
 175       case 'boolean': return object.toString();
 176     }
 177
 178     if (object === null) return 'null';
 179     if (object.toJSON) return object.toJSON();
 180     if (isElement(object)) return;
 181
 182     var results = [];
 183     for (var property in object) {
 184       var value = toJSON(object[property]);
 185       if (!isUndefined(value))
 186         results.push(property.toJSON() + ': ' + value);
 187     }
 188
 189     return '{' + results.join(', ') + '}';
 190   }
 191
 192   function toQueryString(object) {
 193     return $H(object).toQueryString();
 194   }
 195
 196   function toHTML(object) {
 197     return object && object.toHTML ? object.toHTML() : String.interpret(object);
 198   }
 199
 200   function keys(object) {
 201     var results = [];
 202     for (var property in object)
 203       results.push(property);
 204     return results;
 205   }
 206
 207   function values(object) {
 208     var results = [];
 209     for (var property in object)
 210       results.push(object[property]);
 211     return results;
 212   }
 213
 214   function clone(object) {
 215     return extend({ }, object);
 216   }
 217
 218   function isElement(object) {
 219     return !!(object && object.nodeType == 1);
 220   }
 221
 222   function isArray(object) {
 223     return _toString.call(object) == "[object Array]";
 224   }
 225
 226
 227   function isHash(object) {
 228     return object instanceof Hash;
 229   }
 230
 231   function isFunction(object) {
 232     return typeof object === "function";
 233   }
 234
 235   function isString(object) {
 236     return _toString.call(object) == "[object String]";
 237   }
 238
 239   function isNumber(object) {
 240     return _toString.call(object) == "[object Number]";
 241   }
 242
 243   function isUndefined(object) {
 244     return typeof object === "undefined";
 245   }
 246
 247   extend(Object, {
 248     extend:        extend,
 249     inspect:       inspect,
 250     toJSON:        toJSON,
 251     toQueryString: toQueryString,
 252     toHTML:        toHTML,
 253     keys:          keys,
 254     values:        values,
 255     clone:         clone,
 256     isElement:     isElement,
 257     isArray:       isArray,
 258     isHash:        isHash,
 259     isFunction:    isFunction,
 260     isString:      isString,
 261     isNumber:      isNumber,
 262     isUndefined:   isUndefined
 263   });
 264 })();
 265 Object.extend(Function.prototype, (function() {
 266   var slice = Array.prototype.slice;
 267
 268   function update(array, args) {
 269     var arrayLength = array.length, length = args.length;
 270     while (length--) array[arrayLength + length] = args[length];
 271     return array;
 272   }
 273
 274   function merge(array, args) {
 275     array = slice.call(array, 0);
 276     return update(array, args);
 277   }
 278
 279   function argumentNames() {
 280     var names = this.toString().match(/^[\s\(]*function[^(]*\(([^)]*)\)/)[1]
 281       .replace(/\/\/.*?[\r\n]|\/\*(?:.|[\r\n])*?\*\//g, '')
 282       .replace(/\s+/g, '').split(',');
 283     return names.length == 1 && !names[0] ? [] : names;
 284   }
 285
 286   function bind(context) {
 287     if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
 288     var __method = this, args = slice.call(arguments, 1);
 289     return function() {
 290       var a = merge(args, arguments);
 291       return __method.apply(context, a);
 292     }
 293   }
 294
 295   function bindAsEventListener(context) {
 296     var __method = this, args = slice.call(arguments, 1);
 297     return function(event) {
 298       var a = update([event || window.event], args);
 299       return __method.apply(context, a);
 300     }
 301   }
 302
 303   function curry() {
 304     if (!arguments.length) return this;
 305     var __method = this, args = slice.call(arguments, 0);
 306     return function() {
 307       var a = merge(args, arguments);
 308       return __method.apply(this, a);
 309     }
 310   }
 311
 312   function delay(timeout) {
 313     var __method = this, args = slice.call(arguments, 1);
 314     timeout = timeout * 1000
 315     return window.setTimeout(function() {
 316       return __method.apply(__method, args);
 317     }, timeout);
 318   }
 319
 320   function defer() {
 321     var args = update([0.01], arguments);
 322     return this.delay.apply(this, args);
 323   }
 324
 325   function wrap(wrapper) {
 326     var __method = this;
 327     return function() {
 328       var a = update([__method.bind(this)], arguments);
 329       return wrapper.apply(this, a);
 330     }
 331   }
 332
 333   function methodize() {
 334     if (this._methodized) return this._methodized;
 335     var __method = this;
 336     return this._methodized = function() {
 337       var a = update([this], arguments);
 338       return __method.apply(null, a);
 339     };
 340   }
 341
 342   return {
 343     argumentNames:       argumentNames,
 344     bind:                bind,
 345     bindAsEventListener: bindAsEventListener,
 346     curry:               curry,
 347     delay:               delay,
 348     defer:               defer,
 349     wrap:                wrap,
 350     methodize:           methodize
 351   }
 352 })());
 353
 354
 355 Date.prototype.toJSON = function() {
 356   return '"' + this.getUTCFullYear() + '-' +
 357     (this.getUTCMonth() + 1).toPaddedString(2) + '-' +
 358     this.getUTCDate().toPaddedString(2) + 'T' +
 359     this.getUTCHours().toPaddedString(2) + ':' +
 360     this.getUTCMinutes().toPaddedString(2) + ':' +
 361     this.getUTCSeconds().toPaddedString(2) + 'Z"';
 362 };
 363
 364
 365 RegExp.prototype.match = RegExp.prototype.test;
 366
 367 RegExp.escape = function(str) {
 368   return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
 369 };
 370 var PeriodicalExecuter = Class.create({
 371   initialize: function(callback, frequency) {
 372     this.callback = callback;
 373     this.frequency = frequency;
 374     this.currentlyExecuting = false;
 375
 376     this.registerCallback();
 377   },
 378
 379   registerCallback: function() {
 380     this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
 381   },
 382
 383   execute: function() {
 384     this.callback(this);
 385   },
 386
 387   stop: function() {
 388     if (!this.timer) return;
 389     clearInterval(this.timer);
 390     this.timer = null;
 391   },
 392
 393   onTimerEvent: function() {
 394     if (!this.currentlyExecuting) {
 395       try {
 396         this.currentlyExecuting = true;
 397         this.execute();
 398         this.currentlyExecuting = false;
 399       } catch(e) {
 400         this.currentlyExecuting = false;
 401         throw e;
 402       }
 403     }
 404   }
 405 });
 406 Object.extend(String, {
 407   interpret: function(value) {
 408     return value == null ? '' : String(value);
 409   },
 410   specialChar: {
 411     '\b': '\\b',
 412     '\t': '\\t',
 413     '\n': '\\n',
 414     '\f': '\\f',
 415     '\r': '\\r',
 416     '\\': '\\\\'
 417   }
 418 });
 419
 420 Object.extend(String.prototype, (function() {
 421
 422   function prepareReplacement(replacement) {
 423     if (Object.isFunction(replacement)) return replacement;
 424     var template = new Template(replacement);
 425     return function(match) { return template.evaluate(match) };
 426   }
 427
 428   function gsub(pattern, replacement) {
 429     var result = '', source = this, match;
 430     replacement = prepareReplacement(replacement);
 431
 432     if (Object.isString(pattern))
 433       pattern = RegExp.escape(pattern);
 434
 435     if (!(pattern.length || pattern.source)) {
 436       replacement = replacement('');
 437       return replacement + source.split('').join(replacement) + replacement;
 438     }
 439
 440     while (source.length > 0) {
 441       if (match = source.match(pattern)) {
 442         result += source.slice(0, match.index);
 443         result += String.interpret(replacement(match));
 444         source  = source.slice(match.index + match[0].length);
 445       } else {
 446         result += source, source = '';
 447       }
 448     }
 449     return result;
 450   }
 451
 452   function sub(pattern, replacement, count) {
 453     replacement = prepareReplacement(replacement);
 454     count = Object.isUndefined(count) ? 1 : count;
 455
 456     return this.gsub(pattern, function(match) {
 457       if (--count < 0) return match[0];
 458       return replacement(match);
 459     });
 460   }
 461
 462   function scan(pattern, iterator) {
 463     this.gsub(pattern, iterator);
 464     return String(this);
 465   }
 466
 467   function truncate(length, truncation) {
 468     length = length || 30;
 469     truncation = Object.isUndefined(truncation) ? '...' : truncation;
 470     return this.length > length ?
 471       this.slice(0, length - truncation.length) + truncation : String(this);
 472   }
 473
 474   function strip() {
 475     return this.replace(/^\s+/, '').replace(/\s+$/, '');
 476   }
 477
 478   function stripTags() {
 479     return this.replace(/<\w+(\s+("[^"]*"|'[^']*'|[^>])+)?>|<\/\w+>/gi, '');
 480   }
 481
 482   function stripScripts() {
 483     return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
 484   }
 485
 486   function extractScripts() {
 487     var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
 488     var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
 489     return (this.match(matchAll) || []).map(function(scriptTag) {
 490       return (scriptTag.match(matchOne) || ['', ''])[1];
 491     });
 492   }
 493
 494   function evalScripts() {
 495     return this.extractScripts().map(function(script) { return eval(script) });
 496   }
 497
 498   function escapeHTML() {
 499     return this.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
 500   }
 501
 502   function unescapeHTML() {
 503     return this.stripTags().replace(/&lt;/g,'<').replace(/&gt;/g,'>').replace(/&amp;/g,'&');
 504   }
 505
 506
 507   function toQueryParams(separator) {
 508     var match = this.strip().match(/([^?#]*)(#.*)?$/);
 509     if (!match) return { };
 510
 511     return match[1].split(separator || '&').inject({ }, function(hash, pair) {
 512       if ((pair = pair.split('='))[0]) {
 513         var key = decodeURIComponent(pair.shift());
 514         var value = pair.length > 1 ? pair.join('=') : pair[0];
 515         if (value != undefined) value = decodeURIComponent(value);
 516
 517         if (key in hash) {
 518           if (!Object.isArray(hash[key])) hash[key] = [hash[key]];
 519           hash[key].push(value);
 520         }
 521         else hash[key] = value;
 522       }
 523       return hash;
 524     });
 525   }
 526
 527   function toArray() {
 528     return this.split('');
 529   }
 530
 531   function succ() {
 532     return this.slice(0, this.length - 1) +
 533       String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
 534   }
 535
 536   function times(count) {
 537     return count < 1 ? '' : new Array(count + 1).join(this);
 538   }
 539
 540   function camelize() {
 541     var parts = this.split('-'), len = parts.length;
 542     if (len == 1) return parts[0];
 543
 544     var camelized = this.charAt(0) == '-'
 545       ? parts[0].charAt(0).toUpperCase() + parts[0].substring(1)
 546       : parts[0];
 547
 548     for (var i = 1; i < len; i++)
 549       camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);
 550
 551     return camelized;
 552   }
 553
 554   function capitalize() {
 555     return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
 556   }
 557
 558   function underscore() {
 559     return this.replace(/::/g, '/')
 560                .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
 561                .replace(/([a-z\d])([A-Z])/g, '$1_$2')
 562                .replace(/-/g, '_')
 563                .toLowerCase();
 564   }
 565
 566   function dasherize() {
 567     return this.replace(/_/g, '-');
 568   }
 569
 570   function inspect(useDoubleQuotes) {
 571     var escapedString = this.replace(/[\x00-\x1f\\]/g, function(character) {
 572       if (character in String.specialChar) {
 573         return String.specialChar[character];
 574       }
 575       return '\\u00' + character.charCodeAt().toPaddedString(2, 16);
 576     });
 577     if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
 578     return "'" + escapedString.replace(/'/g, '\\\'') + "'";
 579   }
 580
 581   function toJSON() {
 582     return this.inspect(true);
 583   }
 584
 585   function unfilterJSON(filter) {
 586     return this.replace(filter || Prototype.JSONFilter, '$1');
 587   }
 588
 589   function isJSON() {
 590     var str = this;
 591     if (str.blank()) return false;
 592     str = this.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');
 593     return (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(str);
 594   }
 595
 596   function evalJSON(sanitize) {
 597     var json = this.unfilterJSON();
 598     try {
 599       if (!sanitize || json.isJSON()) return eval('(' + json + ')');
 600     } catch (e) { }
 601     throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
 602   }
 603
 604   function include(pattern) {
 605     return this.indexOf(pattern) > -1;
 606   }
 607
 608   function startsWith(pattern) {
 609     return this.indexOf(pattern) === 0;
 610   }
 611
 612   function endsWith(pattern) {
 613     var d = this.length - pattern.length;
 614     return d >= 0 && this.lastIndexOf(pattern) === d;
 615   }
 616
 617   function empty() {
 618     return this == '';
 619   }
 620
 621   function blank() {
 622     return /^\s*$/.test(this);
 623   }
 624
 625   function interpolate(object, pattern) {
 626     return new Template(this, pattern).evaluate(object);
 627   }
 628
 629   return {
 630     gsub:           gsub,
 631     sub:            sub,
 632     scan:           scan,
 633     truncate:       truncate,
 634     strip:          String.prototype.trim ? String.prototype.trim : strip,
 635     stripTags:      stripTags,
 636     stripScripts:   stripScripts,
 637     extractScripts: extractScripts,
 638     evalScripts:    evalScripts,
 639     escapeHTML:     escapeHTML,
 640     unescapeHTML:   unescapeHTML,
 641     toQueryParams:  toQueryParams,
 642     parseQuery:     toQueryParams,
 643     toArray:        toArray,
 644     succ:           succ,
 645     times:          times,
 646     camelize:       camelize,
 647     capitalize:     capitalize,
 648     underscore:     underscore,
 649     dasherize:      dasherize,
 650     inspect:        inspect,
 651     toJSON:         toJSON,
 652     unfilterJSON:   unfilterJSON,
 653     isJSON:         isJSON,
 654     evalJSON:       evalJSON,
 655     include:        include,
 656     startsWith:     startsWith,
 657     endsWith:       endsWith,
 658     empty:          empty,
 659     blank:          blank,
 660     interpolate:    interpolate
 661   };
 662 })());
 663
 664 var Template = Class.create({
 665   initialize: function(template, pattern) {
 666     this.template = template.toString();
 667     this.pattern = pattern || Template.Pattern;
 668   },
 669
 670   evaluate: function(object) {
 671     if (object && Object.isFunction(object.toTemplateReplacements))
 672       object = object.toTemplateReplacements();
 673
 674     return this.template.gsub(this.pattern, function(match) {
 675       if (object == null) return (match[1] + '');
 676
 677       var before = match[1] || '';
 678       if (before == '\\') return match[2];
 679
 680       var ctx = object, expr = match[3];
 681       var pattern = /^([^.[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/;
 682       match = pattern.exec(expr);
 683       if (match == null) return before;
 684
 685       while (match != null) {
 686         var comp = match[1].startsWith('[') ? match[2].replace(/\\\\]/g, ']') : match[1];
 687         ctx = ctx[comp];
 688         if (null == ctx || '' == match[3]) break;
 689         expr = expr.substring('[' == match[3] ? match[1].length : match[0].length);
 690         match = pattern.exec(expr);
 691       }
 692
 693       return before + String.interpret(ctx);
 694     });
 695   }
 696 });
 697 Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
 698
 699 var $break = { };
 700
 701 var Enumerable = (function() {
 702   function each(iterator, context) {
 703     var index = 0;
 704     try {
 705       this._each(function(value) {
 706         iterator.call(context, value, index++);
 707       });
 708     } catch (e) {
 709       if (e != $break) throw e;
 710     }
 711     return this;
 712   }
 713
 714   function eachSlice(number, iterator, context) {
 715     var index = -number, slices = [], array = this.toArray();
 716     if (number < 1) return array;
 717     while ((index += number) < array.length)
 718       slices.push(array.slice(index, index+number));
 719     return slices.collect(iterator, context);
 720   }
 721
 722   function all(iterator, context) {
 723     iterator = iterator || Prototype.K;
 724     var result = true;
 725     this.each(function(value, index) {
 726       result = result && !!iterator.call(context, value, index);
 727       if (!result) throw $break;
 728     });
 729     return result;
 730   }
 731
 732   function any(iterator, context) {
 733     iterator = iterator || Prototype.K;
 734     var result = false;
 735     this.each(function(value, index) {
 736       if (result = !!iterator.call(context, value, index))
 737         throw $break;
 738     });
 739     return result;
 740   }
 741
 742   function collect(iterator, context) {
 743     iterator = iterator || Prototype.K;
 744     var results = [];
 745     this.each(function(value, index) {
 746       results.push(iterator.call(context, value, index));
 747     });
 748     return results;
 749   }
 750
 751   function detect(iterator, context) {
 752     var result;
 753     this.each(function(value, index) {
 754       if (iterator.call(context, value, index)) {
 755         result = value;
 756         throw $break;
 757       }
 758     });
 759     return result;
 760   }
 761
 762   function findAll(iterator, context) {
 763     var results = [];
 764     this.each(function(value, index) {
 765       if (iterator.call(context, value, index))
 766         results.push(value);
 767     });
 768     return results;
 769   }
 770
 771   function grep(filter, iterator, context) {
 772     iterator = iterator || Prototype.K;
 773     var results = [];
 774
 775     if (Object.isString(filter))
 776       filter = new RegExp(RegExp.escape(filter));
 777
 778     this.each(function(value, index) {
 779       if (filter.match(value))
 780         results.push(iterator.call(context, value, index));
 781     });
 782     return results;
 783   }
 784
 785   function include(object) {
 786     if (Object.isFunction(this.indexOf))
 787       if (this.indexOf(object) != -1) return true;
 788
 789     var found = false;
 790     this.each(function(value) {
 791       if (value == object) {
 792         found = true;
 793         throw $break;
 794       }
 795     });
 796     return found;
 797   }
 798
 799   function inGroupsOf(number, fillWith) {
 800     fillWith = Object.isUndefined(fillWith) ? null : fillWith;
 801     return this.eachSlice(number, function(slice) {
 802       while(slice.length < number) slice.push(fillWith);
 803       return slice;
 804     });
 805   }
 806
 807   function inject(memo, iterator, context) {
 808     this.each(function(value, index) {
 809       memo = iterator.call(context, memo, value, index);
 810     });
 811     return memo;
 812   }
 813
 814   function invoke(method) {
 815     var args = $A(arguments).slice(1);
 816     return this.map(function(value) {
 817       return value[method].apply(value, args);
 818     });
 819   }
 820
 821   function max(iterator, context) {
 822     iterator = iterator || Prototype.K;
 823     var result;
 824     this.each(function(value, index) {
 825       value = iterator.call(context, value, index);
 826       if (result == null || value >= result)
 827         result = value;
 828     });
 829     return result;
 830   }
 831
 832   function min(iterator, context) {
 833     iterator = iterator || Prototype.K;
 834     var result;
 835     this.each(function(value, index) {
 836       value = iterator.call(context, value, index);
 837       if (result == null || value < result)
 838         result = value;
 839     });
 840     return result;
 841   }
 842
 843   function partition(iterator, context) {
 844     iterator = iterator || Prototype.K;
 845     var trues = [], falses = [];
 846     this.each(function(value, index) {
 847       (iterator.call(context, value, index) ?
 848         trues : falses).push(value);
 849     });
 850     return [trues, falses];
 851   }
 852
 853   function pluck(property) {
 854     var results = [];
 855     this.each(function(value) {
 856       results.push(value[property]);
 857     });
 858     return results;
 859   }
 860
 861   function reject(iterator, context) {
 862     var results = [];
 863     this.each(function(value, index) {
 864       if (!iterator.call(context, value, index))
 865         results.push(value);
 866     });
 867     return results;
 868   }
 869
 870   function sortBy(iterator, context) {
 871     return this.map(function(value, index) {
 872       return {
 873         value: value,
 874         criteria: iterator.call(context, value, index)
 875       };
 876     }).sort(function(left, right) {
 877       var a = left.criteria, b = right.criteria;
 878       return a < b ? -1 : a > b ? 1 : 0;
 879     }).pluck('value');
 880   }
 881
 882   function toArray() {
 883     return this.map();
 884   }
 885
 886   function zip() {
 887     var iterator = Prototype.K, args = $A(arguments);
 888     if (Object.isFunction(args.last()))
 889       iterator = args.pop();
 890
 891     var collections = [this].concat(args).map($A);
 892     return this.map(function(value, index) {
 893       return iterator(collections.pluck(index));
 894     });
 895   }
 896
 897   function size() {
 898     return this.toArray().length;
 899   }
 900
 901   function inspect() {
 902     return '#<Enumerable:' + this.toArray().inspect() + '>';
 903   }
 904
 905
 906
 907
 908
 909
 910
 911
 912
 913   return {
 914     each:       each,
 915     eachSlice:  eachSlice,
 916     all:        all,
 917     every:      all,
 918     any:        any,
 919     some:       any,
 920     collect:    collect,
 921     map:        collect,
 922     detect:     detect,
 923     findAll:    findAll,
 924     select:     findAll,
 925     filter:     findAll,
 926     grep:       grep,
 927     include:    include,
 928     member:     include,
 929     inGroupsOf: inGroupsOf,
 930     inject:     inject,
 931     invoke:     invoke,
 932     max:        max,
 933     min:        min,
 934     partition:  partition,
 935     pluck:      pluck,
 936     reject:     reject,
 937     sortBy:     sortBy,
 938     toArray:    toArray,
 939     entries:    toArray,
 940     zip:        zip,
 941     size:       size,
 942     inspect:    inspect,
 943     find:       detect
 944   };
 945 })();
 946 function $A(iterable) {
 947   if (!iterable) return [];
 948   if ('toArray' in Object(iterable)) return iterable.toArray();
 949   var length = iterable.length || 0, results = new Array(length);
 950   while (length--) results[length] = iterable[length];
 951   return results;
 952 }
 953
 954 function $w(string) {
 955   if (!Object.isString(string)) return [];
 956   string = string.strip();
 957   return string ? string.split(/\s+/) : [];
 958 }
 959
 960 Array.from = $A;
 961
 962
 963 (function() {
 964   var arrayProto = Array.prototype,
 965       slice = arrayProto.slice,
 966       _each = arrayProto.forEach; // use native browser JS 1.6 implementation if available
 967
 968   function each(iterator) {
 969     for (var i = 0, length = this.length; i < length; i++)
 970       iterator(this[i]);
 971   }
 972   if (!_each) _each = each;
 973
 974   function clear() {
 975     this.length = 0;
 976     return this;
 977   }
 978
 979   function first() {
 980     return this[0];
 981   }
 982
 983   function last() {
 984     return this[this.length - 1];
 985   }
 986
 987   function compact() {
 988     return this.select(function(value) {
 989       return value != null;
 990     });
 991   }
 992
 993   function flatten() {
 994     return this.inject([], function(array, value) {
 995       if (Object.isArray(value))
 996         return array.concat(value.flatten());
 997       array.push(value);
 998       return array;
 999     });
1000   }
1001
1002   function without() {
1003     var values = slice.call(arguments, 0);
1004     return this.select(function(value) {
1005       return !values.include(value);
1006     });
1007   }
1008
1009   function reverse(inline) {
1010     return (inline !== false ? this : this.toArray())._reverse();
1011   }
1012
1013   function uniq(sorted) {
1014     return this.inject([], function(array, value, index) {
1015       if (0 == index || (sorted ? array.last() != value : !array.include(value)))
1016         array.push(value);
1017       return array;
1018     });
1019   }
1020
1021   function intersect(array) {
1022     return this.uniq().findAll(function(item) {
1023       return array.detect(function(value) { return item === value });
1024     });
1025   }
1026
1027
1028   function clone() {
1029     return slice.call(this, 0);
1030   }
1031
1032   function size() {
1033     return this.length;
1034   }
1035
1036   function inspect() {
1037     return '[' + this.map(Object.inspect).join(', ') + ']';
1038   }
1039
1040   function toJSON() {
1041     var results = [];
1042     this.each(function(object) {
1043       var value = Object.toJSON(object);
1044       if (!Object.isUndefined(value)) results.push(value);
1045     });
1046     return '[' + results.join(', ') + ']';
1047   }
1048
1049   function indexOf(item, i) {
1050     i || (i = 0);
1051     var length = this.length;
1052     if (i < 0) i = length + i;
1053     for (; i < length; i++)
1054       if (this[i] === item) return i;
1055     return -1;
1056   }
1057
1058   function lastIndexOf(item, i) {
1059     i = isNaN(i) ? this.length : (i < 0 ? this.length + i : i) + 1;
1060     var n = this.slice(0, i).reverse().indexOf(item);
1061     return (n < 0) ? n : i - n - 1;
1062   }
1063
1064   function concat() {
1065     var array = slice.call(this, 0), item;
1066     for (var i = 0, length = arguments.length; i < length; i++) {
1067       item = arguments[i];
1068       if (Object.isArray(item) && !('callee' in item)) {
1069         for (var j = 0, arrayLength = item.length; j < arrayLength; j++)
1070           array.push(item[j]);
1071       } else {
1072         array.push(item);
1073       }
1074     }
1075     return array;
1076   }
1077
1078   Object.extend(arrayProto, Enumerable);
1079
1080   if (!arrayProto._reverse)
1081     arrayProto._reverse = arrayProto.reverse;
1082
1083   Object.extend(arrayProto, {
1084     _each:     _each,
1085     clear:     clear,
1086     first:     first,
1087     last:      last,
1088     compact:   compact,
1089     flatten:   flatten,
1090     without:   without,
1091     reverse:   reverse,
1092     uniq:      uniq,
1093     intersect: intersect,
1094     clone:     clone,
1095     toArray:   clone,
1096     size:      size,
1097     inspect:   inspect,
1098     toJSON:    toJSON
1099   });
1100
1101   var CONCAT_ARGUMENTS_BUGGY = (function() {
1102     return [].concat(arguments)[0][0] !== 1;
1103   })(1,2)
1104
1105   if (CONCAT_ARGUMENTS_BUGGY) arrayProto.concat = concat;
1106
1107   if (!arrayProto.indexOf) arrayProto.indexOf = indexOf;
1108   if (!arrayProto.lastIndexOf) arrayProto.lastIndexOf = lastIndexOf;
1109 })();
1110 function $H(object) {
1111   return new Hash(object);
1112 };
1113
1114 var Hash = Class.create(Enumerable, (function() {
1115   function initialize(object) {
1116     this._object = Object.isHash(object) ? object.toObject() : Object.clone(object);
1117   }
1118
1119   function _each(iterator) {
1120     for (var key in this._object) {
1121       var value = this._object[key], pair = [key, value];
1122       pair.key = key;
1123       pair.value = value;
1124       iterator(pair);
1125     }
1126   }
1127
1128   function set(key, value) {
1129     return this._object[key] = value;
1130   }
1131
1132   function get(key) {
1133     if (this._object[key] !== Object.prototype[key])
1134       return this._object[key];
1135   }
1136
1137   function unset(key) {
1138     var value = this._object[key];
1139     delete this._object[key];
1140     return value;
1141   }
1142
1143   function toObject() {
1144     return Object.clone(this._object);
1145   }
1146
1147   function keys() {
1148     return this.pluck('key');
1149   }
1150
1151   function values() {
1152     return this.pluck('value');
1153   }
1154
1155   function index(value) {
1156     var match = this.detect(function(pair) {
1157       return pair.value === value;
1158     });
1159     return match && match.key;
1160   }
1161
1162   function merge(object) {
1163     return this.clone().update(object);
1164   }
1165
1166   function update(object) {
1167     return new Hash(object).inject(this, function(result, pair) {
1168       result.set(pair.key, pair.value);
1169       return result;
1170     });
1171   }
1172
1173   function toQueryPair(key, value) {
1174     if (Object.isUndefined(value)) return key;
1175     return key + '=' + encodeURIComponent(String.interpret(value));
1176   }
1177
1178   function toQueryString() {
1179     return this.inject([], function(results, pair) {
1180       var key = encodeURIComponent(pair.key), values = pair.value;
1181
1182       if (values && typeof values == 'object') {
1183         if (Object.isArray(values))
1184           return results.concat(values.map(toQueryPair.curry(key)));
1185       } else results.push(toQueryPair(key, values));
1186       return results;
1187     }).join('&');
1188   }
1189
1190   function inspect() {
1191     return '#<Hash:{' + this.map(function(pair) {
1192       return pair.map(Object.inspect).join(': ');
1193     }).join(', ') + '}>';
1194   }
1195
1196   function toJSON() {
1197     return Object.toJSON(this.toObject());
1198   }
1199
1200   function clone() {
1201     return new Hash(this);
1202   }
1203
1204   return {
1205     initialize:             initialize,
1206     _each:                  _each,
1207     set:                    set,
1208     get:                    get,
1209     unset:                  unset,
1210     toObject:               toObject,
1211     toTemplateReplacements: toObject,
1212     keys:                   keys,
1213     values:                 values,
1214     index:                  index,
1215     merge:                  merge,
1216     update:                 update,
1217     toQueryString:          toQueryString,
1218     inspect:                inspect,
1219     toJSON:                 toJSON,
1220     clone:                  clone
1221   };
1222 })());
1223
1224 Hash.from = $H;
1225 Object.extend(Number.prototype, (function() {
1226   function toColorPart() {
1227     return this.toPaddedString(2, 16);
1228   }
1229
1230   function succ() {
1231     return this + 1;
1232   }
1233
1234   function times(iterator, context) {
1235     $R(0, this, true).each(iterator, context);
1236     return this;
1237   }
1238
1239   function toPaddedString(length, radix) {
1240     var string = this.toString(radix || 10);
1241     return '0'.times(length - string.length) + string;
1242   }
1243
1244   function toJSON() {
1245     return isFinite(this) ? this.toString() : 'null';
1246   }
1247
1248   function abs() {
1249     return Math.abs(this);
1250   }
1251
1252   function round() {
1253     return Math.round(this);
1254   }
1255
1256   function ceil() {
1257     return Math.ceil(this);
1258   }
1259
1260   function floor() {
1261     return Math.floor(this);
1262   }
1263
1264   return {
1265     toColorPart:    toColorPart,
1266     succ:           succ,
1267     times:          times,
1268     toPaddedString: toPaddedString,
1269     toJSON:         toJSON,
1270     abs:            abs,
1271     round:          round,
1272     ceil:           ceil,
1273     floor:          floor
1274   };
1275 })());
1276
1277 function $R(start, end, exclusive) {
1278   return new ObjectRange(start, end, exclusive);
1279 }
1280
1281 var ObjectRange = Class.create(Enumerable, (function() {
1282   function initialize(start, end, exclusive) {
1283     this.start = start;
1284     this.end = end;
1285     this.exclusive = exclusive;
1286   }
1287
1288   function _each(iterator) {
1289     var value = this.start;
1290     while (this.include(value)) {
1291       iterator(value);
1292       value = value.succ();
1293     }
1294   }
1295
1296   function include(value) {
1297     if (value < this.start)
1298       return false;
1299     if (this.exclusive)
1300       return value < this.end;
1301     return value <= this.end;
1302   }
1303
1304   return {
1305     initialize: initialize,
1306     _each:      _each,
1307     include:    include
1308   };
1309 })());
1310
1311
1312
1313 var Ajax = {
1314   getTransport: function() {
1315     return Try.these(
1316       function() {return new XMLHttpRequest()},
1317       function() {return new ActiveXObject('Msxml2.XMLHTTP')},
1318       function() {return new ActiveXObject('Microsoft.XMLHTTP')}
1319     ) || false;
1320   },
1321
1322   activeRequestCount: 0
1323 };
1324
1325 Ajax.Responders = {
1326   responders: [],
1327
1328   _each: function(iterator) {
1329     this.responders._each(iterator);
1330   },
1331
1332   register: function(responder) {
1333     if (!this.include(responder))
1334       this.responders.push(responder);
1335   },
1336
1337   unregister: function(responder) {
1338     this.responders = this.responders.without(responder);
1339   },
1340
1341   dispatch: function(callback, request, transport, json) {
1342     this.each(function(responder) {
1343       if (Object.isFunction(responder[callback])) {
1344         try {
1345           responder[callback].apply(responder, [request, transport, json]);
1346         } catch (e) { }
1347       }
1348     });
1349   }
1350 };
1351
1352 Object.extend(Ajax.Responders, Enumerable);
1353
1354 Ajax.Responders.register({
1355   onCreate:   function() { Ajax.activeRequestCount++ },
1356   onComplete: function() { Ajax.activeRequestCount-- }
1357 });
1358 Ajax.Base = Class.create({
1359   initialize: function(options) {
1360     this.options = {
1361       method:       'post',
1362       asynchronous: true,
1363       contentType:  'application/x-www-form-urlencoded',
1364       encoding:     'UTF-8',
1365       parameters:   '',
1366       evalJSON:     true,
1367       evalJS:       true
1368     };
1369     Object.extend(this.options, options || { });
1370
1371     this.options.method = this.options.method.toLowerCase();
1372
1373     if (Object.isString(this.options.parameters))
1374       this.options.parameters = this.options.parameters.toQueryParams();
1375     else if (Object.isHash(this.options.parameters))
1376       this.options.parameters = this.options.parameters.toObject();
1377   }
1378 });
1379 Ajax.Request = Class.create(Ajax.Base, {
1380   _complete: false,
1381
1382   initialize: function($super, url, options) {
1383     $super(options);
1384     this.transport = Ajax.getTransport();
1385     this.request(url);
1386   },
1387
1388   request: function(url) {
1389     this.url = url;
1390     this.method = this.options.method;
1391     var params = Object.clone(this.options.parameters);
1392
1393     if (!['get', 'post'].include(this.method)) {
1394       params['_method'] = this.method;
1395       this.method = 'post';
1396     }
1397
1398     this.parameters = params;
1399
1400     if (params = Object.toQueryString(params)) {
1401       if (this.method == 'get')
1402         this.url += (this.url.include('?') ? '&' : '?') + params;
1403       else if (/Konqueror|Safari|KHTML/.test(navigator.userAgent))
1404         params += '&_=';
1405     }
1406
1407     try {
1408       var response = new Ajax.Response(this);
1409       if (this.options.onCreate) this.options.onCreate(response);
1410       Ajax.Responders.dispatch('onCreate', this, response);
1411
1412       this.transport.open(this.method.toUpperCase(), this.url,
1413         this.options.asynchronous);
1414
1415       if (this.options.asynchronous) this.respondToReadyState.bind(this).defer(1);
1416
1417       this.transport.onreadystatechange = this.onStateChange.bind(this);
1418       this.setRequestHeaders();
1419
1420       this.body = this.method == 'post' ? (this.options.postBody || params) : null;
1421       this.transport.send(this.body);
1422
1423       /* Force Firefox to handle ready state 4 for synchronous requests */
1424       if (!this.options.asynchronous && this.transport.overrideMimeType)
1425         this.onStateChange();
1426
1427     }
1428     catch (e) {
1429       this.dispatchException(e);
1430     }
1431   },
1432
1433   onStateChange: function() {
1434     var readyState = this.transport.readyState;
1435     if (readyState > 1 && !((readyState == 4) && this._complete))
1436       this.respondToReadyState(this.transport.readyState);
1437   },
1438
1439   setRequestHeaders: function() {
1440     var headers = {
1441       'X-Requested-With': 'XMLHttpRequest',
1442       'X-Prototype-Version': Prototype.Version,
1443       'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
1444     };
1445
1446     if (this.method == 'post') {
1447       headers['Content-type'] = this.options.contentType +
1448         (this.options.encoding ? '; charset=' + this.options.encoding : '');
1449
1450       /* Force "Connection: close" for older Mozilla browsers to work
1451        * around a bug where XMLHttpRequest sends an incorrect
1452        * Content-length header. See Mozilla Bugzilla #246651.
1453        */
1454       if (this.transport.overrideMimeType &&
1455           (navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
1456             headers['Connection'] = 'close';
1457     }
1458
1459     if (typeof this.options.requestHeaders == 'object') {
1460       var extras = this.options.requestHeaders;
1461
1462       if (Object.isFunction(extras.push))
1463         for (var i = 0, length = extras.length; i < length; i += 2)
1464           headers[extras[i]] = extras[i+1];
1465       else
1466         $H(extras).each(function(pair) { headers[pair.key] = pair.value });
1467     }
1468
1469     for (var name in headers)
1470       this.transport.setRequestHeader(name, headers[name]);
1471   },
1472
1473   success: function() {
1474     var status = this.getStatus();
1475     return !status || (status >= 200 && status < 300);
1476   },
1477
1478   getStatus: function() {
1479     try {
1480       return this.transport.status || 0;
1481     } catch (e) { return 0 }
1482   },
1483
1484   respondToReadyState: function(readyState) {
1485     var state = Ajax.Request.Events[readyState], response = new Ajax.Response(this);
1486
1487     if (state == 'Complete') {
1488       try {
1489         this._complete = true;
1490         (this.options['on' + response.status]
1491          || this.options['on' + (this.success() ? 'Success' : 'Failure')]
1492          || Prototype.emptyFunction)(response, response.headerJSON);
1493       } catch (e) {
1494         this.dispatchException(e);
1495       }
1496
1497       var contentType = response.getHeader('Content-type');
1498       if (this.options.evalJS == 'force'
1499           || (this.options.evalJS && this.isSameOrigin() && contentType
1500           && contentType.match(/^\s*(text|application)\/(x-)?(java|ecma)script(;.*)?\s*$/i)))
1501         this.evalResponse();
1502     }
1503
1504     try {
1505       (this.options['on' + state] || Prototype.emptyFunction)(response, response.headerJSON);
1506       Ajax.Responders.dispatch('on' + state, this, response, response.headerJSON);
1507     } catch (e) {
1508       this.dispatchException(e);
1509     }
1510
1511     if (state == 'Complete') {
1512       this.transport.onreadystatechange = Prototype.emptyFunction;
1513     }
1514   },
1515
1516   isSameOrigin: function() {
1517     var m = this.url.match(/^\s*https?:\/\/[^\/]*/);
1518     return !m || (m[0] == '#{protocol}//#{domain}#{port}'.interpolate({
1519       protocol: location.protocol,
1520       domain: document.domain,
1521       port: location.port ? ':' + location.port : ''
1522     }));
1523   },
1524
1525   getHeader: function(name) {
1526     try {
1527       return this.transport.getResponseHeader(name) || null;
1528     } catch (e) { return null; }
1529   },
1530
1531   evalResponse: function() {
1532     try {
1533       return eval((this.transport.responseText || '').unfilterJSON());
1534     } catch (e) {
1535       this.dispatchException(e);
1536     }
1537   },
1538
1539   dispatchException: function(exception) {
1540     (this.options.onException || Prototype.emptyFunction)(this, exception);
1541     Ajax.Responders.dispatch('onException', this, exception);
1542   }
1543 });
1544
1545 Ajax.Request.Events =
1546   ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];
1547
1548
1549
1550
1551
1552
1553
1554
1555 Ajax.Response = Class.create({
1556   initialize: function(request){
1557     this.request = request;
1558     var transport  = this.transport  = request.transport,
1559         readyState = this.readyState = transport.readyState;
1560
1561     if((readyState > 2 && !Prototype.Browser.IE) || readyState == 4) {
1562       this.status       = this.getStatus();
1563       this.statusText   = this.getStatusText();
1564       this.responseText = String.interpret(transport.responseText);
1565       this.headerJSON   = this._getHeaderJSON();
1566     }
1567
1568     if(readyState == 4) {
1569       var xml = transport.responseXML;
1570       this.responseXML  = Object.isUndefined(xml) ? null : xml;
1571       this.responseJSON = this._getResponseJSON();
1572     }
1573   },
1574
1575   status:      0,
1576
1577   statusText: '',
1578
1579   getStatus: Ajax.Request.prototype.getStatus,
1580
1581   getStatusText: function() {
1582     try {
1583       return this.transport.statusText || '';
1584     } catch (e) { return '' }
1585   },
1586
1587   getHeader: Ajax.Request.prototype.getHeader,
1588
1589   getAllHeaders: function() {
1590     try {
1591       return this.getAllResponseHeaders();
1592     } catch (e) { return null }
1593   },
1594
1595   getResponseHeader: function(name) {
1596     return this.transport.getResponseHeader(name);
1597   },
1598
1599   getAllResponseHeaders: function() {
1600     return this.transport.getAllResponseHeaders();
1601   },
1602
1603   _getHeaderJSON: function() {
1604     var json = this.getHeader('X-JSON');
1605     if (!json) return null;
1606     json = decodeURIComponent(escape(json));
1607     try {
1608       return json.evalJSON(this.request.options.sanitizeJSON ||
1609         !this.request.isSameOrigin());
1610     } catch (e) {
1611       this.request.dispatchException(e);
1612     }
1613   },
1614
1615   _getResponseJSON: function() {
1616     var options = this.request.options;
1617     if (!options.evalJSON || (options.evalJSON != 'force' &&
1618       !(this.getHeader('Content-type') || '').include('application/json')) ||
1619         this.responseText.blank())
1620           return null;
1621     try {
1622       return this.responseText.evalJSON(options.sanitizeJSON ||
1623         !this.request.isSameOrigin());
1624     } catch (e) {
1625       this.request.dispatchException(e);
1626     }
1627   }
1628 });
1629
1630 Ajax.Updater = Class.create(Ajax.Request, {
1631   initialize: function($super, container, url, options) {
1632     this.container = {
1633       success: (container.success || container),
1634       failure: (container.failure || (container.success ? null : container))
1635     };
1636
1637     options = Object.clone(options);
1638     var onComplete = options.onComplete;
1639     options.onComplete = (function(response, json) {
1640       this.updateContent(response.responseText);
1641       if (Object.isFunction(onComplete)) onComplete(response, json);
1642     }).bind(this);
1643
1644     $super(url, options);
1645   },
1646
1647   updateContent: function(responseText) {
1648     var receiver = this.container[this.success() ? 'success' : 'failure'],
1649         options = this.options;
1650
1651     if (!options.evalScripts) responseText = responseText.stripScripts();
1652
1653     if (receiver = $(receiver)) {
1654       if (options.insertion) {
1655         if (Object.isString(options.insertion)) {
1656           var insertion = { }; insertion[options.insertion] = responseText;
1657           receiver.insert(insertion);
1658         }
1659         else options.insertion(receiver, responseText);
1660       }
1661       else receiver.update(responseText);
1662     }
1663   }
1664 });
1665
1666 Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1667   initialize: function($super, container, url, options) {
1668     $super(options);
1669     this.onComplete = this.options.onComplete;
1670
1671     this.frequency = (this.options.frequency || 2);
1672     this.decay = (this.options.decay || 1);
1673
1674     this.updater = { };
1675     this.container = container;
1676     this.url = url;
1677
1678     this.start();
1679   },
1680
1681   start: function() {
1682     this.options.onComplete = this.updateComplete.bind(this);
1683     this.onTimerEvent();
1684   },
1685
1686   stop: function() {
1687     this.updater.options.onComplete = undefined;
1688     clearTimeout(this.timer);
1689     (this.onComplete || Prototype.emptyFunction).apply(this, arguments);
1690   },
1691
1692   updateComplete: function(response) {
1693     if (this.options.decay) {
1694       this.decay = (response.responseText == this.lastText ?
1695         this.decay * this.options.decay : 1);
1696
1697       this.lastText = response.responseText;
1698     }
1699     this.timer = this.onTimerEvent.bind(this).delay(this.decay * this.frequency);
1700   },
1701
1702   onTimerEvent: function() {
1703     this.updater = new Ajax.Updater(this.container, this.url, this.options);
1704   }
1705 });
1706
1707
1708
1709 function $(element) {
1710   if (arguments.length > 1) {
1711     for (var i = 0, elements = [], length = arguments.length; i < length; i++)
1712       elements.push($(arguments[i]));
1713     return elements;
1714   }
1715   if (Object.isString(element))
1716     element = document.getElementById(element);
1717   return Element.extend(element);
1718 }
1719
1720 if (Prototype.BrowserFeatures.XPath) {
1721   document._getElementsByXPath = function(expression, parentElement) {
1722     var results = [];
1723     var query = document.evaluate(expression, $(parentElement) || document,
1724       null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
1725     for (var i = 0, length = query.snapshotLength; i < length; i++)
1726       results.push(Element.extend(query.snapshotItem(i)));
1727     return results;
1728   };
1729 }
1730
1731 /*--------------------------------------------------------------------------*/
1732
1733 if (!window.Node) var Node = { };
1734
1735 if (!Node.ELEMENT_NODE) {
1736   Object.extend(Node, {
1737     ELEMENT_NODE: 1,
1738     ATTRIBUTE_NODE: 2,
1739     TEXT_NODE: 3,
1740     CDATA_SECTION_NODE: 4,
1741     ENTITY_REFERENCE_NODE: 5,
1742     ENTITY_NODE: 6,
1743     PROCESSING_INSTRUCTION_NODE: 7,
1744     COMMENT_NODE: 8,
1745     DOCUMENT_NODE: 9,
1746     DOCUMENT_TYPE_NODE: 10,
1747     DOCUMENT_FRAGMENT_NODE: 11,
1748     NOTATION_NODE: 12
1749   });
1750 }
1751
1752
1753 (function(global) {
1754
1755   var SETATTRIBUTE_IGNORES_NAME = (function(){
1756     var elForm = document.createElement("form");
1757     var elInput = document.createElement("input");
1758     var root = document.documentElement;
1759     elInput.setAttribute("name", "test");
1760     elForm.appendChild(elInput);
1761     root.appendChild(elForm);
1762     var isBuggy = elForm.elements
1763       ? (typeof elForm.elements.test == "undefined")
1764       : null;
1765     root.removeChild(elForm);
1766     elForm = elInput = null;
1767     return isBuggy;
1768   })();
1769
1770   var element = global.Element;
1771   global.Element = function(tagName, attributes) {
1772     attributes = attributes || { };
1773     tagName = tagName.toLowerCase();
1774     var cache = Element.cache;
1775     if (SETATTRIBUTE_IGNORES_NAME && attributes.name) {
1776       tagName = '<' + tagName + ' name="' + attributes.name + '">';
1777       delete attributes.name;
1778       return Element.writeAttribute(document.createElement(tagName), attributes);
1779     }
1780     if (!cache[tagName]) cache[tagName] = Element.extend(document.createElement(tagName));
1781     return Element.writeAttribute(cache[tagName].cloneNode(false), attributes);
1782   };
1783   Object.extend(global.Element, element || { });
1784   if (element) global.Element.prototype = element.prototype;
1785 })(this);
1786
1787 Element.cache = { };
1788 Element.idCounter = 1;
1789
1790 Element.Methods = {
1791   visible: function(element) {
1792     return $(element).style.display != 'none';
1793   },
1794
1795   toggle: function(element) {
1796     element = $(element);
1797     Element[Element.visible(element) ? 'hide' : 'show'](element);
1798     return element;
1799   },
1800
1801
1802   hide: function(element) {
1803     element = $(element);
1804     element.style.display = 'none';
1805     return element;
1806   },
1807
1808   show: function(element) {
1809     element = $(element);
1810     element.style.display = '';
1811     return element;
1812   },
1813
1814   remove: function(element) {
1815     element = $(element);
1816     element.parentNode.removeChild(element);
1817     return element;
1818   },
1819
1820   update: (function(){
1821
1822     var SELECT_ELEMENT_INNERHTML_BUGGY = (function(){
1823       var el = document.createElement("select"),
1824           isBuggy = true;
1825       el.innerHTML = "<option value=\"test\">test</option>";
1826       if (el.options && el.options[0]) {
1827         isBuggy = el.options[0].nodeName.toUpperCase() !== "OPTION";
1828       }
1829       el = null;
1830       return isBuggy;
1831     })();
1832
1833     var TABLE_ELEMENT_INNERHTML_BUGGY = (function(){
1834       try {
1835         var el = document.createElement("table");
1836         if (el && el.tBodies) {
1837           el.innerHTML = "<tbody><tr><td>test</td></tr></tbody>";
1838           var isBuggy = typeof el.tBodies[0] == "undefined";
1839           el = null;
1840           return isBuggy;
1841         }
1842       } catch (e) {
1843         return true;
1844       }
1845     })();
1846
1847     var SCRIPT_ELEMENT_REJECTS_TEXTNODE_APPENDING = (function () {
1848       var s = document.createElement("script"),
1849           isBuggy = false;
1850       try {
1851         s.appendChild(document.createTextNode(""));
1852         isBuggy = !s.firstChild ||
1853           s.firstChild && s.firstChild.nodeType !== 3;
1854       } catch (e) {
1855         isBuggy = true;
1856       }
1857       s = null;
1858       return isBuggy;
1859     })();
1860
1861     function update(element, content) {
1862       element = $(element);
1863
1864       if (content && content.toElement)
1865         content = content.toElement();
1866
1867       if (Object.isElement(content))
1868         return element.update().insert(content);
1869
1870       content = Object.toHTML(content);
1871
1872       var tagName = element.tagName.toUpperCase();
1873
1874       if (tagName === 'SCRIPT' && SCRIPT_ELEMENT_REJECTS_TEXTNODE_APPENDING) {
1875         element.text = content;
1876         return element;
1877       }
1878
1879       if (SELECT_ELEMENT_INNERHTML_BUGGY || TABLE_ELEMENT_INNERHTML_BUGGY) {
1880         if (tagName in Element._insertionTranslations.tags) {
1881           while (element.firstChild) {
1882             element.removeChild(element.firstChild);
1883           }
1884           Element._getContentFromAnonymousElement(tagName, content.stripScripts())
1885             .each(function(node) {
1886               element.appendChild(node)
1887             });
1888         }
1889         else {
1890           element.innerHTML = content.stripScripts();
1891         }
1892       }
1893       else {
1894         element.innerHTML = content.stripScripts();
1895       }
1896
1897       content.evalScripts.bind(content).defer();
1898       return element;
1899     }
1900
1901     return update;
1902   })(),
1903
1904   replace: function(element, content) {
1905     element = $(element);
1906     if (content && content.toElement) content = content.toElement();
1907     else if (!Object.isElement(content)) {
1908       content = Object.toHTML(content);
1909       var range = element.ownerDocument.createRange();
1910       range.selectNode(element);
1911       content.evalScripts.bind(content).defer();
1912       content = range.createContextualFragment(content.stripScripts());
1913     }
1914     element.parentNode.replaceChild(content, element);
1915     return element;
1916   },
1917
1918   insert: function(element, insertions) {
1919     element = $(element);
1920
1921     if (Object.isString(insertions) || Object.isNumber(insertions) ||
1922         Object.isElement(insertions) || (insertions && (insertions.toElement || insertions.toHTML)))
1923           insertions = {bottom:insertions};
1924
1925     var content, insert, tagName, childNodes;
1926
1927     for (var position in insertions) {
1928       content  = insertions[position];
1929       position = position.toLowerCase();
1930       insert = Element._insertionTranslations[position];
1931
1932       if (content && content.toElement) content = content.toElement();
1933       if (Object.isElement(content)) {
1934         insert(element, content);
1935         continue;
1936       }
1937
1938       content = Object.toHTML(content);
1939
1940       tagName = ((position == 'before' || position == 'after')
1941         ? element.parentNode : element).tagName.toUpperCase();
1942
1943       childNodes = Element._getContentFromAnonymousElement(tagName, content.stripScripts());
1944
1945       if (position == 'top' || position == 'after') childNodes.reverse();
1946       childNodes.each(insert.curry(element));
1947
1948       content.evalScripts.bind(content).defer();
1949     }
1950
1951     return element;
1952   },
1953
1954   wrap: function(element, wrapper, attributes) {
1955     element = $(element);
1956     if (Object.isElement(wrapper))
1957       $(wrapper).writeAttribute(attributes || { });
1958     else if (Object.isString(wrapper)) wrapper = new Element(wrapper, attributes);
1959     else wrapper = new Element('div', wrapper);
1960     if (element.parentNode)
1961       element.parentNode.replaceChild(wrapper, element);
1962     wrapper.appendChild(element);
1963     return wrapper;
1964   },
1965
1966   inspect: function(element) {
1967     element = $(element);
1968     var result = '<' + element.tagName.toLowerCase();
1969     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
1970       var property = pair.first(), attribute = pair.last();
1971       var value = (element[property] || '').toString();
1972       if (value) result += ' ' + attribute + '=' + value.inspect(true);
1973     });
1974     return result + '>';
1975   },
1976
1977   recursivelyCollect: function(element, property) {
1978     element = $(element);
1979     var elements = [];
1980     while (element = element[property])
1981       if (element.nodeType == 1)
1982         elements.push(Element.extend(element));
1983     return elements;
1984   },
1985
1986   ancestors: function(element) {
1987     return Element.recursivelyCollect(element, 'parentNode');
1988   },
1989
1990   descendants: function(element) {
1991     return Element.select(element, "*");
1992   },
1993
1994   firstDescendant: function(element) {
1995     element = $(element).firstChild;
1996     while (element && element.nodeType != 1) element = element.nextSibling;
1997     return $(element);
1998   },
1999
2000   immediateDescendants: function(element) {
2001     if (!(element = $(element).firstChild)) return [];
2002     while (element && element.nodeType != 1) element = element.nextSibling;
2003     if (element) return [element].concat($(element).nextSiblings());
2004     return [];
2005   },
2006
2007   previousSiblings: function(element) {
2008     return Element.recursivelyCollect(element, 'previousSibling');
2009   },
2010
2011   nextSiblings: function(element) {
2012     return Element.recursivelyCollect(element, 'nextSibling');
2013   },
2014
2015   siblings: function(element) {
2016     element = $(element);
2017     return Element.previousSiblings(element).reverse()
2018       .concat(Element.nextSiblings(element));
2019   },
2020
2021   match: function(element, selector) {
2022     if (Object.isString(selector))
2023       selector = new Selector(selector);
2024     return selector.match($(element));
2025   },
2026
2027   up: function(element, expression, index) {
2028     element = $(element);
2029     if (arguments.length == 1) return $(element.parentNode);
2030     var ancestors = Element.ancestors(element);
2031     return Object.isNumber(expression) ? ancestors[expression] :
2032       Selector.findElement(ancestors, expression, index);
2033   },
2034
2035   down: function(element, expression, index) {
2036     element = $(element);
2037     if (arguments.length == 1) return Element.firstDescendant(element);
2038     return Object.isNumber(expression) ? Element.descendants(element)[expression] :
2039       Element.select(element, expression)[index || 0];
2040   },
2041
2042   previous: function(element, expression, index) {
2043     element = $(element);
2044     if (arguments.length == 1) return $(Selector.handlers.previousElementSibling(element));
2045     var previousSiblings = Element.previousSiblings(element);
2046     return Object.isNumber(expression) ? previousSiblings[expression] :
2047       Selector.findElement(previousSiblings, expression, index);
2048   },
2049
2050   next: function(element, expression, index) {
2051     element = $(element);
2052     if (arguments.length == 1) return $(Selector.handlers.nextElementSibling(element));
2053     var nextSiblings = Element.nextSiblings(element);
2054     return Object.isNumber(expression) ? nextSiblings[expression] :
2055       Selector.findElement(nextSiblings, expression, index);
2056   },
2057
2058
2059   select: function(element) {
2060     var args = Array.prototype.slice.call(arguments, 1);
2061     return Selector.findChildElements(element, args);
2062   },
2063
2064   adjacent: function(element) {
2065     var args = Array.prototype.slice.call(arguments, 1);
2066     return Selector.findChildElements(element.parentNode, args).without(element);
2067   },
2068
2069   identify: function(element) {
2070     element = $(element);
2071     var id = Element.readAttribute(element, 'id');
2072     if (id) return id;
2073     do { id = 'anonymous_element_' + Element.idCounter++ } while ($(id));
2074     Element.writeAttribute(element, 'id', id);
2075     return id;
2076   },
2077
2078   readAttribute: function(element, name) {
2079     element = $(element);
2080     if (Prototype.Browser.IE) {
2081       var t = Element._attributeTranslations.read;
2082       if (t.values[name]) return t.values[name](element, name);
2083       if (t.names[name]) name = t.names[name];
2084       if (name.include(':')) {
2085         return (!element.attributes || !element.attributes[name]) ? null :
2086          element.attributes[name].value;
2087       }
2088     }
2089     return element.getAttribute(name);
2090   },
2091
2092   writeAttribute: function(element, name, value) {
2093     element = $(element);
2094     var attributes = { }, t = Element._attributeTranslations.write;
2095
2096     if (typeof name == 'object') attributes = name;
2097     else attributes[name] = Object.isUndefined(value) ? true : value;
2098
2099     for (var attr in attributes) {
2100       name = t.names[attr] || attr;
2101       value = attributes[attr];
2102       if (t.values[attr]) name = t.values[attr](element, value);
2103       if (value === false || value === null)
2104         element.removeAttribute(name);
2105       else if (value === true)
2106         element.setAttribute(name, name);
2107       else element.setAttribute(name, value);
2108     }
2109     return element;
2110   },
2111
2112   getHeight: function(element) {
2113     return Element.getDimensions(element).height;
2114   },
2115
2116   getWidth: function(element) {
2117     return Element.getDimensions(element).width;
2118   },
2119
2120   classNames: function(element) {
2121     return new Element.ClassNames(element);
2122   },
2123
2124   hasClassName: function(element, className) {
2125     if (!(element = $(element))) return;
2126     var elementClassName = element.className;
2127     return (elementClassName.length > 0 && (elementClassName == className ||
2128       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
2129   },
2130
2131   addClassName: function(element, className) {
2132     if (!(element = $(element))) return;
2133     if (!Element.hasClassName(element, className))
2134       element.className += (element.className ? ' ' : '') + className;
2135     return element;
2136   },
2137
2138   removeClassName: function(element, className) {
2139     if (!(element = $(element))) return;
2140     element.className = element.className.replace(
2141       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
2142     return element;
2143   },
2144
2145   toggleClassName: function(element, className) {
2146     if (!(element = $(element))) return;
2147     return Element[Element.hasClassName(element, className) ?
2148       'removeClassName' : 'addClassName'](element, className);
2149   },
2150
2151   cleanWhitespace: function(element) {
2152     element = $(element);
2153     var node = element.firstChild;
2154     while (node) {
2155       var nextNode = node.nextSibling;
2156       if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
2157         element.removeChild(node);
2158       node = nextNode;
2159     }
2160     return element;
2161   },
2162
2163   empty: function(element) {
2164     return $(element).innerHTML.blank();
2165   },
2166
2167   descendantOf: function(element, ancestor) {
2168     element = $(element), ancestor = $(ancestor);
2169
2170     if (element.compareDocumentPosition)
2171       return (element.compareDocumentPosition(ancestor) & 8) === 8;
2172
2173     if (ancestor.contains)
2174       return ancestor.contains(element) && ancestor !== element;
2175
2176     while (element = element.parentNode)
2177       if (element == ancestor) return true;
2178
2179     return false;
2180   },
2181
2182   scrollTo: function(element) {
2183     element = $(element);
2184     var pos = Element.cumulativeOffset(element);
2185     window.scrollTo(pos[0], pos[1]);
2186     return element;
2187   },
2188
2189   getStyle: function(element, style) {
2190     element = $(element);
2191     style = style == 'float' ? 'cssFloat' : style.camelize();
2192     var value = element.style[style];
2193     if (!value || value == 'auto') {
2194       var css = document.defaultView.getComputedStyle(element, null);
2195       value = css ? css[style] : null;
2196     }
2197     if (style == 'opacity') return value ? parseFloat(value) : 1.0;
2198     return value == 'auto' ? null : value;
2199   },
2200
2201   getOpacity: function(element) {
2202     return $(element).getStyle('opacity');
2203   },
2204
2205   setStyle: function(element, styles) {
2206     element = $(element);
2207     var elementStyle = element.style, match;
2208     if (Object.isString(styles)) {
2209       element.style.cssText += ';' + styles;
2210       return styles.include('opacity') ?
2211         element.setOpacity(styles.match(/opacity:\s*(\d?\.?\d*)/)[1]) : element;
2212     }
2213     for (var property in styles)
2214       if (property == 'opacity') element.setOpacity(styles[property]);
2215       else
2216         elementStyle[(property == 'float' || property == 'cssFloat') ?
2217           (Object.isUndefined(elementStyle.styleFloat) ? 'cssFloat' : 'styleFloat') :
2218             property] = styles[property];
2219
2220     return element;
2221   },
2222
2223   setOpacity: function(element, value) {
2224     element = $(element);
2225     element.style.opacity = (value == 1 || value === '') ? '' :
2226       (value < 0.00001) ? 0 : value;
2227     return element;
2228   },
2229
2230   getDimensions: function(element) {
2231     element = $(element);
2232     var display = Element.getStyle(element, 'display');
2233     if (display != 'none' && display != null) // Safari bug
2234       return {width: element.offsetWidth, height: element.offsetHeight};
2235
2236     var els = element.style;
2237     var originalVisibility = els.visibility;
2238     var originalPosition = els.position;
2239     var originalDisplay = els.display;
2240     els.visibility = 'hidden';
2241     if (originalPosition != 'fixed') // Switching fixed to absolute causes issues in Safari
2242       els.position = 'absolute';
2243     els.display = 'block';
2244     var originalWidth = element.clientWidth;
2245     var originalHeight = element.clientHeight;
2246     els.display = originalDisplay;
2247     els.position = originalPosition;
2248     els.visibility = originalVisibility;
2249     return {width: originalWidth, height: originalHeight};
2250   },
2251
2252   makePositioned: function(element) {
2253     element = $(element);
2254     var pos = Element.getStyle(element, 'position');
2255     if (pos == 'static' || !pos) {
2256       element._madePositioned = true;
2257       element.style.position = 'relative';
2258       if (Prototype.Browser.Opera) {
2259         element.style.top = 0;
2260         element.style.left = 0;
2261       }
2262     }
2263     return element;
2264   },
2265
2266   undoPositioned: function(element) {
2267     element = $(element);
2268     if (element._madePositioned) {
2269       element._madePositioned = undefined;
2270       element.style.position =
2271         element.style.top =
2272         element.style.left =
2273         element.style.bottom =
2274         element.style.right = '';
2275     }
2276     return element;
2277   },
2278
2279   makeClipping: function(element) {
2280     element = $(element);
2281     if (element._overflow) return element;
2282     element._overflow = Element.getStyle(element, 'overflow') || 'auto';
2283     if (element._overflow !== 'hidden')
2284       element.style.overflow = 'hidden';
2285     return element;
2286   },
2287
2288   undoClipping: function(element) {
2289     element = $(element);
2290     if (!element._overflow) return element;
2291     element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
2292     element._overflow = null;
2293     return element;
2294   },
2295
2296   cumulativeOffset: function(element) {
2297     var valueT = 0, valueL = 0;
2298     do {
2299       valueT += element.offsetTop  || 0;
2300       valueL += element.offsetLeft || 0;
2301       element = element.offsetParent;
2302     } while (element);
2303     return Element._returnOffset(valueL, valueT);
2304   },
2305
2306   positionedOffset: function(element) {
2307     var valueT = 0, valueL = 0;
2308     do {
2309       valueT += element.offsetTop  || 0;
2310       valueL += element.offsetLeft || 0;
2311       element = element.offsetParent;
2312       if (element) {
2313         if (element.tagName.toUpperCase() == 'BODY') break;
2314         var p = Element.getStyle(element, 'position');
2315         if (p !== 'static') break;
2316       }
2317     } while (element);
2318     return Element._returnOffset(valueL, valueT);
2319   },
2320
2321   absolutize: function(element) {
2322     element = $(element);
2323     if (Element.getStyle(element, 'position') == 'absolute') return element;
2324
2325     var offsets = Element.positionedOffset(element);
2326     var top     = offsets[1];
2327     var left    = offsets[0];
2328     var width   = element.clientWidth;
2329     var height  = element.clientHeight;
2330
2331     element._originalLeft   = left - parseFloat(element.style.left  || 0);
2332     element._originalTop    = top  - parseFloat(element.style.top || 0);
2333     element._originalWidth  = element.style.width;
2334     element._originalHeight = element.style.height;
2335
2336     element.style.position = 'absolute';
2337     element.style.top    = top + 'px';
2338     element.style.left   = left + 'px';
2339     element.style.width  = width + 'px';
2340     element.style.height = height + 'px';
2341     return element;
2342   },
2343
2344   relativize: function(element) {
2345     element = $(element);
2346     if (Element.getStyle(element, 'position') == 'relative') return element;
2347
2348     element.style.position = 'relative';
2349     var top  = parseFloat(element.style.top  || 0) - (element._originalTop || 0);
2350     var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);
2351
2352     element.style.top    = top + 'px';
2353     element.style.left   = left + 'px';
2354     element.style.height = element._originalHeight;
2355     element.style.width  = element._originalWidth;
2356     return element;
2357   },
2358
2359   cumulativeScrollOffset: function(element) {
2360     var valueT = 0, valueL = 0;
2361     do {
2362       valueT += element.scrollTop  || 0;
2363       valueL += element.scrollLeft || 0;
2364       element = element.parentNode;
2365     } while (element);
2366     return Element._returnOffset(valueL, valueT);
2367   },
2368
2369   getOffsetParent: function(element) {
2370     if (element.offsetParent) return $(element.offsetParent);
2371     if (element == document.body) return $(element);
2372
2373     while ((element = element.parentNode) && element != document.body)
2374       if (Element.getStyle(element, 'position') != 'static')
2375         return $(element);
2376
2377     return $(document.body);
2378   },
2379
2380   viewportOffset: function(forElement) {
2381     var valueT = 0, valueL = 0;
2382
2383     var element = forElement;
2384     do {
2385       valueT += element.offsetTop  || 0;
2386       valueL += element.offsetLeft || 0;
2387
2388       if (element.offsetParent == document.body &&
2389         Element.getStyle(element, 'position') == 'absolute') break;
2390
2391     } while (element = element.offsetParent);
2392
2393     element = forElement;
2394     do {
2395       if (!Prototype.Browser.Opera || (element.tagName && (element.tagName.toUpperCase() == 'BODY'))) {
2396         valueT -= element.scrollTop  || 0;
2397         valueL -= element.scrollLeft || 0;
2398       }
2399     } while (element = element.parentNode);
2400
2401     return Element._returnOffset(valueL, valueT);
2402   },
2403
2404   clonePosition: function(element, source) {
2405     var options = Object.extend({
2406       setLeft:    true,
2407       setTop:     true,
2408       setWidth:   true,
2409       setHeight:  true,
2410       offsetTop:  0,
2411       offsetLeft: 0
2412     }, arguments[2] || { });
2413
2414     source = $(source);
2415     var p = Element.viewportOffset(source);
2416
2417     element = $(element);
2418     var delta = [0, 0];
2419     var parent = null;
2420     if (Element.getStyle(element, 'position') == 'absolute') {
2421       parent = Element.getOffsetParent(element);
2422       delta = Element.viewportOffset(parent);
2423     }
2424
2425     if (parent == document.body) {
2426       delta[0] -= document.body.offsetLeft;
2427       delta[1] -= document.body.offsetTop;
2428     }
2429
2430     if (options.setLeft)   element.style.left  = (p[0] - delta[0] + options.offsetLeft) + 'px';
2431     if (options.setTop)    element.style.top   = (p[1] - delta[1] + options.offsetTop) + 'px';
2432     if (options.setWidth)  element.style.width = source.offsetWidth + 'px';
2433     if (options.setHeight) element.style.height = source.offsetHeight + 'px';
2434     return element;
2435   }
2436 };
2437
2438 Object.extend(Element.Methods, {
2439   getElementsBySelector: Element.Methods.select,
2440
2441   childElements: Element.Methods.immediateDescendants
2442 });
2443
2444 Element._attributeTranslations = {
2445   write: {
2446     names: {
2447       className: 'class',
2448       htmlFor:   'for'
2449     },
2450     values: { }
2451   }
2452 };
2453
2454 if (Prototype.Browser.Opera) {
2455   Element.Methods.getStyle = Element.Methods.getStyle.wrap(
2456     function(proceed, element, style) {
2457       switch (style) {
2458         case 'left': case 'top': case 'right': case 'bottom':
2459           if (proceed(element, 'position') === 'static') return null;
2460         case 'height': case 'width':
2461           if (!Element.visible(element)) return null;
2462
2463           var dim = parseInt(proceed(element, style), 10);
2464
2465           if (dim !== element['offset' + style.capitalize()])
2466             return dim + 'px';
2467
2468           var properties;
2469           if (style === 'height') {
2470             properties = ['border-top-width', 'padding-top',
2471              'padding-bottom', 'border-bottom-width'];
2472           }
2473           else {
2474             properties = ['border-left-width', 'padding-left',
2475              'padding-right', 'border-right-width'];
2476           }
2477           return properties.inject(dim, function(memo, property) {
2478             var val = proceed(element, property);
2479             return val === null ? memo : memo - parseInt(val, 10);
2480           }) + 'px';
2481         default: return proceed(element, style);
2482       }
2483     }
2484   );
2485
2486   Element.Methods.readAttribute = Element.Methods.readAttribute.wrap(
2487     function(proceed, element, attribute) {
2488       if (attribute === 'title') return element.title;
2489       return proceed(element, attribute);
2490     }
2491   );
2492 }
2493
2494 else if (Prototype.Browser.IE) {
2495   Element.Methods.getOffsetParent = Element.Methods.getOffsetParent.wrap(
2496     function(proceed, element) {
2497       element = $(element);
2498       try { element.offsetParent }
2499       catch(e) { return $(document.body) }
2500       var position = element.getStyle('position');
2501       if (position !== 'static') return proceed(element);
2502       element.setStyle({ position: 'relative' });
2503       var value = proceed(element);
2504       element.setStyle({ position: position });
2505       return value;
2506     }
2507   );
2508
2509   $w('positionedOffset viewportOffset').each(function(method) {
2510     Element.Methods[method] = Element.Methods[method].wrap(
2511       function(proceed, element) {
2512         element = $(element);
2513         try { element.offsetParent }
2514         catch(e) { return Element._returnOffset(0,0) }
2515         var position = element.getStyle('position');
2516         if (position !== 'static') return proceed(element);
2517         var offsetParent = element.getOffsetParent();
2518         if (offsetParent && offsetParent.getStyle('position') === 'fixed')
2519           offsetParent.setStyle({ zoom: 1 });
2520         element.setStyle({ position: 'relative' });
2521         var value = proceed(element);
2522         element.setStyle({ position: position });
2523         return value;
2524       }
2525     );
2526   });
2527
2528   Element.Methods.cumulativeOffset = Element.Methods.cumulativeOffset.wrap(
2529     function(proceed, element) {
2530       try { element.offsetParent }
2531       catch(e) { return Element._returnOffset(0,0) }
2532       return proceed(element);
2533     }
2534   );
2535
2536   Element.Methods.getStyle = function(element, style) {
2537     element = $(element);
2538     style = (style == 'float' || style == 'cssFloat') ? 'styleFloat' : style.camelize();
2539     var value = element.style[style];
2540     if (!value && element.currentStyle) value = element.currentStyle[style];
2541
2542     if (style == 'opacity') {
2543       if (value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
2544         if (value[1]) return parseFloat(value[1]) / 100;
2545       return 1.0;
2546     }
2547
2548     if (value == 'auto') {
2549       if ((style == 'width' || style == 'height') && (element.getStyle('display') != 'none'))
2550         return element['offset' + style.capitalize()] + 'px';
2551       return null;
2552     }
2553     return value;
2554   };
2555
2556   Element.Methods.setOpacity = function(element, value) {
2557     function stripAlpha(filter){
2558       return filter.replace(/alpha\([^\)]*\)/gi,'');
2559     }
2560     element = $(element);
2561     var currentStyle = element.currentStyle;
2562     if ((currentStyle && !currentStyle.hasLayout) ||
2563       (!currentStyle && element.style.zoom == 'normal'))
2564         element.style.zoom = 1;
2565
2566     var filter = element.getStyle('filter'), style = element.style;
2567     if (value == 1 || value === '') {
2568       (filter = stripAlpha(filter)) ?
2569         style.filter = filter : style.removeAttribute('filter');
2570       return element;
2571     } else if (value < 0.00001) value = 0;
2572     style.filter = stripAlpha(filter) +
2573       'alpha(opacity=' + (value * 100) + ')';
2574     return element;
2575   };
2576
2577   Element._attributeTranslations = (function(){
2578
2579     var classProp = 'className';
2580     var forProp = 'for';
2581
2582     var el = document.createElement('div');
2583
2584     el.setAttribute(classProp, 'x');
2585
2586     if (el.className !== 'x') {
2587       el.setAttribute('class', 'x');
2588       if (el.className === 'x') {
2589         classProp = 'class';
2590       }
2591     }
2592     el = null;
2593
2594     el = document.createElement('label');
2595     el.setAttribute(forProp, 'x');
2596     if (el.htmlFor !== 'x') {
2597       el.setAttribute('htmlFor', 'x');
2598       if (el.htmlFor === 'x') {
2599         forProp = 'htmlFor';
2600       }
2601     }
2602     el = null;
2603
2604     return {
2605       read: {
2606         names: {
2607           'class':      classProp,
2608           'className':  classProp,
2609           'for':        forProp,
2610           'htmlFor':    forProp
2611         },
2612         values: {
2613           _getAttr: function(element, attribute) {
2614             return element.getAttribute(attribute);
2615           },
2616           _getAttr2: function(element, attribute) {
2617             return element.getAttribute(attribute, 2);
2618           },
2619           _getAttrNode: function(element, attribute) {
2620             var node = element.getAttributeNode(attribute);
2621             return node ? node.value : "";
2622           },
2623           _getEv: (function(){
2624
2625             var el = document.createElement('div');
2626             el.onclick = Prototype.emptyFunction;
2627             var value = el.getAttribute('onclick');
2628             var f;
2629
2630             if (String(value).indexOf('{') > -1) {
2631               f = function(element, attribute) {
2632                 attribute = element.getAttribute(attribute);
2633                 if (!attribute) return null;
2634                 attribute = attribute.toString();
2635                 attribute = attribute.split('{')[1];
2636                 attribute = attribute.split('}')[0];
2637                 return attribute.strip();
2638               };
2639             }
2640             else if (value === '') {
2641               f = function(element, attribute) {
2642                 attribute = element.getAttribute(attribute);
2643                 if (!attribute) return null;
2644                 return attribute.strip();
2645               };
2646             }
2647             el = null;
2648             return f;
2649           })(),
2650           _flag: function(element, attribute) {
2651             return $(element).hasAttribute(attribute) ? attribute : null;
2652           },
2653           style: function(element) {
2654             return element.style.cssText.toLowerCase();
2655           },
2656           title: function(element) {
2657             return element.title;
2658           }
2659         }
2660       }
2661     }
2662   })();
2663
2664   Element._attributeTranslations.write = {
2665     names: Object.extend({
2666       cellpadding: 'cellPadding',
2667       cellspacing: 'cellSpacing'
2668     }, Element._attributeTranslations.read.names),
2669     values: {
2670       checked: function(element, value) {
2671         element.checked = !!value;
2672       },
2673
2674       style: function(element, value) {
2675         element.style.cssText = value ? value : '';
2676       }
2677     }
2678   };
2679
2680   Element._attributeTranslations.has = {};
2681
2682   $w('colSpan rowSpan vAlign dateTime accessKey tabIndex ' +
2683       'encType maxLength readOnly longDesc frameBorder').each(function(attr) {
2684     Element._attributeTranslations.write.names[attr.toLowerCase()] = attr;
2685     Element._attributeTranslations.has[attr.toLowerCase()] = attr;
2686   });
2687
2688   (function(v) {
2689     Object.extend(v, {
2690       href:        v._getAttr2,
2691       src:         v._getAttr2,
2692       type:        v._getAttr,
2693       action:      v._getAttrNode,
2694       disabled:    v._flag,
2695       checked:     v._flag,
2696       readonly:    v._flag,
2697       multiple:    v._flag,
2698       onload:      v._getEv,
2699       onunload:    v._getEv,
2700       onclick:     v._getEv,
2701       ondblclick:  v._getEv,
2702       onmousedown: v._getEv,
2703       onmouseup:   v._getEv,
2704       onmouseover: v._getEv,
2705       onmousemove: v._getEv,
2706       onmouseout:  v._getEv,
2707       onfocus:     v._getEv,
2708       onblur:      v._getEv,
2709       onkeypress:  v._getEv,
2710       onkeydown:   v._getEv,
2711       onkeyup:     v._getEv,
2712       onsubmit:    v._getEv,
2713       onreset:     v._getEv,
2714       onselect:    v._getEv,
2715       onchange:    v._getEv
2716     });
2717   })(Element._attributeTranslations.read.values);
2718
2719   if (Prototype.BrowserFeatures.ElementExtensions) {
2720     (function() {
2721       function _descendants(element) {
2722         var nodes = element.getElementsByTagName('*'), results = [];
2723         for (var i = 0, node; node = nodes[i]; i++)
2724           if (node.tagName !== "!") // Filter out comment nodes.
2725             results.push(node);
2726         return results;
2727       }
2728
2729       Element.Methods.down = function(element, expression, index) {
2730         element = $(element);
2731         if (arguments.length == 1) return element.firstDescendant();
2732         return Object.isNumber(expression) ? _descendants(element)[expression] :
2733           Element.select(element, expression)[index || 0];
2734       }
2735     })();
2736   }
2737
2738 }
2739
2740 else if (Prototype.Browser.Gecko && /rv:1\.8\.0/.test(navigator.userAgent)) {
2741   Element.Methods.setOpacity = function(element, value) {
2742     element = $(element);
2743     element.style.opacity = (value == 1) ? 0.999999 :
2744       (value === '') ? '' : (value < 0.00001) ? 0 : value;
2745     return element;
2746   };
2747 }
2748
2749 else if (Prototype.Browser.WebKit) {
2750   Element.Methods.setOpacity = function(element, value) {
2751     element = $(element);
2752     element.style.opacity = (value == 1 || value === '') ? '' :
2753       (value < 0.00001) ? 0 : value;
2754
2755     if (value == 1)
2756       if(element.tagName.toUpperCase() == 'IMG' && element.width) {
2757         element.width++; element.width--;
2758       } else try {
2759         var n = document.createTextNode(' ');
2760         element.appendChild(n);
2761         element.removeChild(n);
2762       } catch (e) { }
2763
2764     return element;
2765   };
2766
2767   Element.Methods.cumulativeOffset = function(element) {
2768     var valueT = 0, valueL = 0;
2769     do {
2770       valueT += element.offsetTop  || 0;
2771       valueL += element.offsetLeft || 0;
2772       if (element.offsetParent == document.body)
2773         if (Element.getStyle(element, 'position') == 'absolute') break;
2774
2775       element = element.offsetParent;
2776     } while (element);
2777
2778     return Element._returnOffset(valueL, valueT);
2779   };
2780 }
2781
2782 if ('outerHTML' in document.documentElement) {
2783   Element.Methods.replace = function(element, content) {
2784     element = $(element);
2785
2786     if (content && content.toElement) content = content.toElement();
2787     if (Object.isElement(content)) {
2788       element.parentNode.replaceChild(content, element);
2789       return element;
2790     }
2791
2792     content = Object.toHTML(content);
2793     var parent = element.parentNode, tagName = parent.tagName.toUpperCase();
2794
2795     if (Element._insertionTranslations.tags[tagName]) {
2796       var nextSibling = element.next();
2797       var fragments = Element._getContentFromAnonymousElement(tagName, content.stripScripts());
2798       parent.removeChild(element);
2799       if (nextSibling)
2800         fragments.each(function(node) { parent.insertBefore(node, nextSibling) });
2801       else
2802         fragments.each(function(node) { parent.appendChild(node) });
2803     }
2804     else element.outerHTML = content.stripScripts();
2805
2806     content.evalScripts.bind(content).defer();
2807     return element;
2808   };
2809 }
2810
2811 Element._returnOffset = function(l, t) {
2812   var result = [l, t];
2813   result.left = l;
2814   result.top = t;
2815   return result;
2816 };
2817
2818 Element._getContentFromAnonymousElement = function(tagName, html) {
2819   var div = new Element('div'), t = Element._insertionTranslations.tags[tagName];
2820   if (t) {
2821     div.innerHTML = t[0] + html + t[1];
2822     t[2].times(function() { div = div.firstChild });
2823   } else div.innerHTML = html;
2824   return $A(div.childNodes);
2825 };
2826
2827 Element._insertionTranslations = {
2828   before: function(element, node) {
2829     element.parentNode.insertBefore(node, element);
2830   },
2831   top: function(element, node) {
2832     element.insertBefore(node, element.firstChild);
2833   },
2834   bottom: function(element, node) {
2835     element.appendChild(node);
2836   },
2837   after: function(element, node) {
2838     element.parentNode.insertBefore(node, element.nextSibling);
2839   },
2840   tags: {
2841     TABLE:  ['<table>',                '</table>',                   1],
2842     TBODY:  ['<table><tbody>',         '</tbody></table>',           2],
2843     TR:     ['<table><tbody><tr>',     '</tr></tbody></table>',      3],
2844     TD:     ['<table><tbody><tr><td>', '</td></tr></tbody></table>', 4],
2845     SELECT: ['<select>',               '</select>',                  1]
2846   }
2847 };
2848
2849 (function() {
2850   var tags = Element._insertionTranslations.tags;
2851   Object.extend(tags, {
2852     THEAD: tags.TBODY,
2853     TFOOT: tags.TBODY,
2854     TH:    tags.TD
2855   });
2856 })();
2857
2858 Element.Methods.Simulated = {
2859   hasAttribute: function(element, attribute) {
2860     attribute = Element._attributeTranslations.has[attribute] || attribute;
2861     var node = $(element).getAttributeNode(attribute);
2862     return !!(node && node.specified);
2863   }
2864 };
2865
2866 Element.Methods.ByTag = { };
2867
2868 Object.extend(Element, Element.Methods);
2869
2870 (function(div) {
2871
2872   if (!Prototype.BrowserFeatures.ElementExtensions && div['__proto__']) {
2873     window.HTMLElement = { };
2874     window.HTMLElement.prototype = div['__proto__'];
2875     Prototype.BrowserFeatures.ElementExtensions = true;
2876   }
2877
2878   div = null;
2879
2880 })(document.createElement('div'))
2881
2882 Element.extend = (function() {
2883
2884   function checkDeficiency(tagName) {
2885     if (typeof window.Element != 'undefined') {
2886       var proto = window.Element.prototype;
2887       if (proto) {
2888         var id = '_' + (Math.random()+'').slice(2);
2889         var el = document.createElement(tagName);
2890         proto[id] = 'x';
2891         var isBuggy = (el[id] !== 'x');
2892         delete proto[id];
2893         el = null;
2894         return isBuggy;
2895       }
2896     }
2897     return false;
2898   }
2899
2900   function extendElementWith(element, methods) {
2901     for (var property in methods) {
2902       var value = methods[property];
2903       if (Object.isFunction(value) && !(property in element))
2904         element[property] = value.methodize();
2905     }
2906   }
2907
2908   var HTMLOBJECTELEMENT_PROTOTYPE_BUGGY = checkDeficiency('object');
2909
2910   if (Prototype.BrowserFeatures.SpecificElementExtensions) {
2911     if (HTMLOBJECTELEMENT_PROTOTYPE_BUGGY) {
2912       return function(element) {
2913         if (element && typeof element._extendedByPrototype == 'undefined') {
2914           var t = element.tagName;
2915           if (t && (/^(?:object|applet|embed)$/i.test(t))) {
2916             extendElementWith(element, Element.Methods);
2917             extendElementWith(element, Element.Methods.Simulated);
2918             extendElementWith(element, Element.Methods.ByTag[t.toUpperCase()]);
2919           }
2920         }
2921         return element;
2922       }
2923     }
2924     return Prototype.K;
2925   }
2926
2927   var Methods = { }, ByTag = Element.Methods.ByTag;
2928
2929   var extend = Object.extend(function(element) {
2930     if (!element || typeof element._extendedByPrototype != 'undefined' ||
2931         element.nodeType != 1 || element == window) return element;
2932
2933     var methods = Object.clone(Methods),
2934         tagName = element.tagName.toUpperCase();
2935
2936     if (ByTag[tagName]) Object.extend(methods, ByTag[tagName]);
2937
2938     extendElementWith(element, methods);
2939
2940     element._extendedByPrototype = Prototype.emptyFunction;
2941     return element;
2942
2943   }, {
2944     refresh: function() {
2945       if (!Prototype.BrowserFeatures.ElementExtensions) {
2946         Object.extend(Methods, Element.Methods);
2947         Object.extend(Methods, Element.Methods.Simulated);
2948       }
2949     }
2950   });
2951
2952   extend.refresh();
2953   return extend;
2954 })();
2955
2956 Element.hasAttribute = function(element, attribute) {
2957   if (element.hasAttribute) return element.hasAttribute(attribute);
2958   return Element.Methods.Simulated.hasAttribute(element, attribute);
2959 };
2960
2961 Element.addMethods = function(methods) {
2962   var F = Prototype.BrowserFeatures, T = Element.Methods.ByTag;
2963
2964   if (!methods) {
2965     Object.extend(Form, Form.Methods);
2966     Object.extend(Form.Element, Form.Element.Methods);
2967     Object.extend(Element.Methods.ByTag, {
2968       "FORM":     Object.clone(Form.Methods),
2969       "INPUT":    Object.clone(Form.Element.Methods),
2970       "SELECT":   Object.clone(Form.Element.Methods),
2971       "TEXTAREA": Object.clone(Form.Element.Methods)
2972     });
2973   }
2974
2975   if (arguments.length == 2) {
2976     var tagName = methods;
2977     methods = arguments[1];
2978   }
2979
2980   if (!tagName) Object.extend(Element.Methods, methods || { });
2981   else {
2982     if (Object.isArray(tagName)) tagName.each(extend);
2983     else extend(tagName);
2984   }
2985
2986   function extend(tagName) {
2987     tagName = tagName.toUpperCase();
2988     if (!Element.Methods.ByTag[tagName])
2989       Element.Methods.ByTag[tagName] = { };
2990     Object.extend(Element.Methods.ByTag[tagName], methods);
2991   }
2992
2993   function copy(methods, destination, onlyIfAbsent) {
2994     onlyIfAbsent = onlyIfAbsent || false;
2995     for (var property in methods) {
2996       var value = methods[property];
2997       if (!Object.isFunction(value)) continue;
2998       if (!onlyIfAbsent || !(property in destination))
2999         destination[property] = value.methodize();
3000     }
3001   }
3002
3003   function findDOMClass(tagName) {
3004     var klass;
3005     var trans = {
3006       "OPTGROUP": "OptGroup", "TEXTAREA": "TextArea", "P": "Paragraph",
3007       "FIELDSET": "FieldSet", "UL": "UList", "OL": "OList", "DL": "DList",
3008       "DIR": "Directory", "H1": "Heading", "H2": "Heading", "H3": "Heading",
3009       "H4": "Heading", "H5": "Heading", "H6": "Heading", "Q": "Quote",
3010       "INS": "Mod", "DEL": "Mod", "A": "Anchor", "IMG": "Image", "CAPTION":
3011       "TableCaption", "COL": "TableCol", "COLGROUP": "TableCol", "THEAD":
3012       "TableSection", "TFOOT": "TableSection", "TBODY": "TableSection", "TR":
3013       "TableRow", "TH": "TableCell", "TD": "TableCell", "FRAMESET":
3014       "FrameSet", "IFRAME": "IFrame"
3015     };
3016     if (trans[tagName]) klass = 'HTML' + trans[tagName] + 'Element';
3017     if (window[klass]) return window[klass];
3018     klass = 'HTML' + tagName + 'Element';
3019     if (window[klass]) return window[klass];
3020     klass = 'HTML' + tagName.capitalize() + 'Element';
3021     if (window[klass]) return window[klass];
3022
3023     var element = document.createElement(tagName);
3024     var proto = element['__proto__'] || element.constructor.prototype;
3025     element = null;
3026     return proto;
3027   }
3028
3029   var elementPrototype = window.HTMLElement ? HTMLElement.prototype :
3030    Element.prototype;
3031
3032   if (F.ElementExtensions) {
3033     copy(Element.Methods, elementPrototype);
3034     copy(Element.Methods.Simulated, elementPrototype, true);
3035   }
3036
3037   if (F.SpecificElementExtensions) {
3038     for (var tag in Element.Methods.ByTag) {
3039       var klass = findDOMClass(tag);
3040       if (Object.isUndefined(klass)) continue;
3041       copy(T[tag], klass.prototype);
3042     }
3043   }
3044
3045   Object.extend(Element, Element.Methods);
3046   delete Element.ByTag;
3047
3048   if (Element.extend.refresh) Element.extend.refresh();
3049   Element.cache = { };
3050 };
3051
3052
3053 document.viewport = {
3054
3055   getDimensions: function() {
3056     return { width: this.getWidth(), height: this.getHeight() };
3057   },
3058
3059   getScrollOffsets: function() {
3060     return Element._returnOffset(
3061       window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft,
3062       window.pageYOffset || document.documentElement.scrollTop  || document.body.scrollTop);
3063   }
3064 };
3065
3066 (function(viewport) {
3067   var B = Prototype.Browser, doc = document, element, property = {};
3068
3069   function getRootElement() {
3070     if (B.WebKit && !doc.evaluate)
3071       return document;
3072
3073     if (B.Opera && window.parseFloat(window.opera.version()) < 9.5)
3074       return document.body;
3075
3076     return document.documentElement;
3077   }
3078
3079   function define(D) {
3080     if (!element) element = getRootElement();
3081
3082     property[D] = 'client' + D;
3083
3084     viewport['get' + D] = function() { return element[property[D]] };
3085     return viewport['get' + D]();
3086   }
3087
3088   viewport.getWidth  = define.curry('Width');
3089
3090   viewport.getHeight = define.curry('Height');
3091 })(document.viewport);
3092
3093
3094 Element.Storage = {
3095   UID: 1
3096 };
3097
3098 Element.addMethods({
3099   getStorage: function(element) {
3100     if (!(element = $(element))) return;
3101
3102     var uid;
3103     if (element === window) {
3104       uid = 0;
3105     } else {
3106       if (typeof element._prototypeUID === "undefined")
3107         element._prototypeUID = [Element.Storage.UID++];
3108       uid = element._prototypeUID[0];
3109     }
3110
3111     if (!Element.Storage[uid])
3112       Element.Storage[uid] = $H();
3113
3114     return Element.Storage[uid];
3115   },
3116
3117   store: function(element, key, value) {
3118     if (!(element = $(element))) return;
3119
3120     if (arguments.length === 2) {
3121       Element.getStorage(element).update(key);
3122     } else {
3123       Element.getStorage(element).set(key, value);
3124     }
3125
3126     return element;
3127   },
3128
3129   retrieve: function(element, key, defaultValue) {
3130     if (!(element = $(element))) return;
3131     var hash = Element.getStorage(element), value = hash.get(key);
3132
3133     if (Object.isUndefined(value)) {
3134       hash.set(key, defaultValue);
3135       value = defaultValue;
3136     }
3137
3138     return value;
3139   },
3140
3141   clone: function(element, deep) {
3142     if (!(element = $(element))) return;
3143     var clone = element.cloneNode(deep);
3144     clone._prototypeUID = void 0;
3145     if (deep) {
3146       var descendants = Element.select(clone, '*'),
3147           i = descendants.length;
3148       while (i--) {
3149         descendants[i]._prototypeUID = void 0;
3150       }
3151     }
3152     return Element.extend(clone);
3153   }
3154 });
3155 /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
3156  * part of YUI-Ext version 0.40, distributed under the terms of an MIT-style
3157  * license.  Please see http://www.yui-ext.com/ for more information. */
3158
3159 var Selector = Class.create({
3160   initialize: function(expression) {
3161     this.expression = expression.strip();
3162
3163     if (this.shouldUseSelectorsAPI()) {
3164       this.mode = 'selectorsAPI';
3165     } else if (this.shouldUseXPath()) {
3166       this.mode = 'xpath';
3167       this.compileXPathMatcher();
3168     } else {
3169       this.mode = "normal";
3170       this.compileMatcher();
3171     }
3172
3173   },
3174
3175   shouldUseXPath: (function() {
3176
3177     var IS_DESCENDANT_SELECTOR_BUGGY = (function(){
3178       var isBuggy = false;
3179       if (document.evaluate && window.XPathResult) {
3180         var el = document.createElement('div');
3181         el.innerHTML = '<ul><li></li></ul><div><ul><li></li></ul></div>';
3182
3183         var xpath = ".//*[local-name()='ul' or local-name()='UL']" +
3184           "//*[local-name()='li' or local-name()='LI']";
3185
3186         var result = document.evaluate(xpath, el, null,
3187           XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
3188
3189         isBuggy = (result.snapshotLength !== 2);
3190         el = null;
3191       }
3192       return isBuggy;
3193     })();
3194
3195     return function() {
3196       if (!Prototype.BrowserFeatures.XPath) return false;
3197
3198       var e = this.expression;
3199
3200       if (Prototype.Browser.WebKit &&
3201        (e.include("-of-type") || e.include(":empty")))
3202         return false;
3203
3204       if ((/(\[[\w-]*?:|:checked)/).test(e))
3205         return false;
3206
3207       if (IS_DESCENDANT_SELECTOR_BUGGY) return false;
3208
3209       return true;
3210     }
3211
3212   })(),
3213
3214   shouldUseSelectorsAPI: function() {
3215     if (!Prototype.BrowserFeatures.SelectorsAPI) return false;
3216
3217     if (Selector.CASE_INSENSITIVE_CLASS_NAMES) return false;
3218
3219     if (!Selector._div) Selector._div = new Element('div');
3220
3221     try {
3222       Selector._div.querySelector(this.expression);
3223     } catch(e) {
3224       return false;
3225     }
3226
3227     return true;
3228   },
3229
3230   compileMatcher: function() {
3231     var e = this.expression, ps = Selector.patterns, h = Selector.handlers,
3232         c = Selector.criteria, le, p, m, len = ps.length, name;
3233
3234     if (Selector._cache[e]) {
3235       this.matcher = Selector._cache[e];
3236       return;
3237     }
3238
3239     this.matcher = ["this.matcher = function(root) {",
3240                     "var r = root, h = Selector.handlers, c = false, n;"];
3241
3242     while (e && le != e && (/\S/).test(e)) {
3243       le = e;
3244       for (var i = 0; i<len; i++) {
3245         p = ps[i].re;
3246         name = ps[i].name;
3247         if (m = e.match(p)) {
3248           this.matcher.push(Object.isFunction(c[name]) ? c[name](m) :
3249             new Template(c[name]).evaluate(m));
3250           e = e.replace(m[0], '');
3251           break;
3252         }
3253       }
3254     }
3255
3256     this.matcher.push("return h.unique(n);\n}");
3257     eval(this.matcher.join('\n'));
3258     Selector._cache[this.expression] = this.matcher;
3259   },
3260
3261   compileXPathMatcher: function() {
3262     var e = this.expression, ps = Selector.patterns,
3263         x = Selector.xpath, le, m, len = ps.length, name;
3264
3265     if (Selector._cache[e]) {
3266       this.xpath = Selector._cache[e]; return;
3267     }
3268
3269     this.matcher = ['.//*'];
3270     while (e && le != e && (/\S/).test(e)) {
3271       le = e;
3272       for (var i = 0; i<len; i++) {
3273         name = ps[i].name;
3274         if (m = e.match(ps[i].re)) {
3275           this.matcher.push(Object.isFunction(x[name]) ? x[name](m) :
3276             new Template(x[name]).evaluate(m));
3277           e = e.replace(m[0], '');
3278           break;
3279         }
3280       }
3281     }
3282
3283     this.xpath = this.matcher.join('');
3284     Selector._cache[this.expression] = this.xpath;
3285   },
3286
3287   findElements: function(root) {
3288     root = root || document;
3289     var e = this.expression, results;
3290
3291     switch (this.mode) {
3292       case 'selectorsAPI':
3293         if (root !== document) {
3294           var oldId = root.id, id = $(root).identify();
3295           id = id.replace(/([\.:])/g, "\\$1");
3296           e = "#" + id + " " + e;
3297         }
3298
3299         results = $A(root.querySelectorAll(e)).map(Element.extend);
3300         root.id = oldId;
3301
3302         return results;
3303       case 'xpath':
3304         return document._getElementsByXPath(this.xpath, root);
3305       default:
3306        return this.matcher(root);
3307     }
3308   },
3309
3310   match: function(element) {
3311     this.tokens = [];
3312
3313     var e = this.expression, ps = Selector.patterns, as = Selector.assertions;
3314     var le, p, m, len = ps.length, name;
3315
3316     while (e && le !== e && (/\S/).test(e)) {
3317       le = e;
3318       for (var i = 0; i<len; i++) {
3319         p = ps[i].re;
3320         name = ps[i].name;
3321         if (m = e.match(p)) {
3322           if (as[name]) {
3323             this.tokens.push([name, Object.clone(m)]);
3324             e = e.replace(m[0], '');
3325           } else {
3326             return this.findElements(document).include(element);
3327           }
3328         }
3329       }
3330     }
3331
3332     var match = true, name, matches;
3333     for (var i = 0, token; token = this.tokens[i]; i++) {
3334       name = token[0], matches = token[1];
3335       if (!Selector.assertions[name](element, matches)) {
3336         match = false; break;
3337       }
3338     }
3339
3340     return match;
3341   },
3342
3343   toString: function() {
3344     return this.expression;
3345   },
3346
3347   inspect: function() {
3348     return "#<Selector:" + this.expression.inspect() + ">";
3349   }
3350 });
3351
3352 if (Prototype.BrowserFeatures.SelectorsAPI &&
3353  document.compatMode === 'BackCompat') {
3354   Selector.CASE_INSENSITIVE_CLASS_NAMES = (function(){
3355     var div = document.createElement('div'),
3356      span = document.createElement('span');
3357
3358     div.id = "prototype_test_id";
3359     span.className = 'Test';
3360     div.appendChild(span);
3361     var isIgnored = (div.querySelector('#prototype_test_id .test') !== null);
3362     div = span = null;
3363     return isIgnored;
3364   })();
3365 }
3366
3367 Object.extend(Selector, {
3368   _cache: { },
3369
3370   xpath: {
3371     descendant:   "//*",
3372     child:        "/*",
3373     adjacent:     "/following-sibling::*[1]",
3374     laterSibling: '/following-sibling::*',
3375     tagName:      function(m) {
3376       if (m[1] == '*') return '';
3377       return "[local-name()='" + m[1].toLowerCase() +
3378              "' or local-name()='" + m[1].toUpperCase() + "']";
3379     },
3380     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3381     id:           "[@id='#{1}']",
3382     attrPresence: function(m) {
3383       m[1] = m[1].toLowerCase();
3384       return new Template("[@#{1}]").evaluate(m);
3385     },
3386     attr: function(m) {
3387       m[1] = m[1].toLowerCase();
3388       m[3] = m[5] || m[6];
3389       return new Template(Selector.xpath.operators[m[2]]).evaluate(m);
3390     },
3391     pseudo: function(m) {
3392       var h = Selector.xpath.pseudos[m[1]];
3393       if (!h) return '';
3394       if (Object.isFunction(h)) return h(m);
3395       return new Template(Selector.xpath.pseudos[m[1]]).evaluate(m);
3396     },
3397     operators: {
3398       '=':  "[@#{1}='#{3}']",
3399       '!=': "[@#{1}!='#{3}']",
3400       '^=': "[starts-with(@#{1}, '#{3}')]",
3401       '$=': "[substring(@#{1}, (string-length(@#{1}) - string-length('#{3}') + 1))='#{3}']",
3402       '*=': "[contains(@#{1}, '#{3}')]",
3403       '~=': "[contains(concat(' ', @#{1}, ' '), ' #{3} ')]",
3404       '|=': "[contains(concat('-', @#{1}, '-'), '-#{3}-')]"
3405     },
3406     pseudos: {
3407       'first-child': '[not(preceding-sibling::*)]',
3408       'last-child':  '[not(following-sibling::*)]',
3409       'only-child':  '[not(preceding-sibling::* or following-sibling::*)]',
3410       'empty':       "[count(*) = 0 and (count(text()) = 0)]",
3411       'checked':     "[@checked]",
3412       'disabled':    "[(@disabled) and (@type!='hidden')]",
3413       'enabled':     "[not(@disabled) and (@type!='hidden')]",
3414       'not': function(m) {
3415         var e = m[6], p = Selector.patterns,
3416             x = Selector.xpath, le, v, len = p.length, name;
3417
3418         var exclusion = [];
3419         while (e && le != e && (/\S/).test(e)) {
3420           le = e;
3421           for (var i = 0; i<len; i++) {
3422             name = p[i].name
3423             if (m = e.match(p[i].re)) {
3424               v = Object.isFunction(x[name]) ? x[name](m) : new Template(x[name]).evaluate(m);
3425               exclusion.push("(" + v.substring(1, v.length - 1) + ")");
3426               e = e.replace(m[0], '');
3427               break;
3428             }
3429           }
3430         }
3431         return "[not(" + exclusion.join(" and ") + ")]";
3432       },
3433       'nth-child':      function(m) {
3434         return Selector.xpath.pseudos.nth("(count(./preceding-sibling::*) + 1) ", m);
3435       },
3436       'nth-last-child': function(m) {
3437         return Selector.xpath.pseudos.nth("(count(./following-sibling::*) + 1) ", m);
3438       },
3439       'nth-of-type':    function(m) {
3440         return Selector.xpath.pseudos.nth("position() ", m);
3441       },
3442       'nth-last-of-type': function(m) {
3443         return Selector.xpath.pseudos.nth("(last() + 1 - position()) ", m);
3444       },
3445       'first-of-type':  function(m) {
3446         m[6] = "1"; return Selector.xpath.pseudos['nth-of-type'](m);
3447       },
3448       'last-of-type':   function(m) {
3449         m[6] = "1"; return Selector.xpath.pseudos['nth-last-of-type'](m);
3450       },
3451       'only-of-type':   function(m) {
3452         var p = Selector.xpath.pseudos; return p['first-of-type'](m) + p['last-of-type'](m);
3453       },
3454       nth: function(fragment, m) {
3455         var mm, formula = m[6], predicate;
3456         if (formula == 'even') formula = '2n+0';
3457         if (formula == 'odd')  formula = '2n+1';
3458         if (mm = formula.match(/^(\d+)$/)) // digit only
3459           return '[' + fragment + "= " + mm[1] + ']';
3460         if (mm = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
3461           if (mm[1] == "-") mm[1] = -1;
3462           var a = mm[1] ? Number(mm[1]) : 1;
3463           var b = mm[2] ? Number(mm[2]) : 0;
3464           predicate = "[((#{fragment} - #{b}) mod #{a} = 0) and " +
3465           "((#{fragment} - #{b}) div #{a} >= 0)]";
3466           return new Template(predicate).evaluate({
3467             fragment: fragment, a: a, b: b });
3468         }
3469       }
3470     }
3471   },
3472
3473   criteria: {
3474     tagName:      'n = h.tagName(n, r, "#{1}", c);      c = false;',
3475     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
3476     id:           'n = h.id(n, r, "#{1}", c);           c = false;',
3477     attrPresence: 'n = h.attrPresence(n, r, "#{1}", c); c = false;',
3478     attr: function(m) {
3479       m[3] = (m[5] || m[6]);
3480       return new Template('n = h.attr(n, r, "#{1}", "#{3}", "#{2}", c); c = false;').evaluate(m);
3481     },
3482     pseudo: function(m) {
3483       if (m[6]) m[6] = m[6].replace(/"/g, '\\"');
3484       return new Template('n = h.pseudo(n, "#{1}", "#{6}", r, c); c = false;').evaluate(m);
3485     },
3486     descendant:   'c = "descendant";',
3487     child:        'c = "child";',
3488     adjacent:     'c = "adjacent";',
3489     laterSibling: 'c = "laterSibling";'
3490   },
3491
3492   patterns: [
3493     { name: 'laterSibling', re: /^\s*~\s*/ },
3494     { name: 'child',        re: /^\s*>\s*/ },
3495     { name: 'adjacent',     re: /^\s*\+\s*/ },
3496     { name: 'descendant',   re: /^\s/ },
3497
3498     { name: 'tagName',      re: /^\s*(\*|[\w\-]+)(\b|$)?/ },
3499     { name: 'id',           re: /^#([\w\-\*]+)(\b|$)/ },
3500     { name: 'className',    re: /^\.([\w\-\*]+)(\b|$)/ },
3501     { name: 'pseudo',       re: /^:((first|last|nth|nth-last|only)(-child|-of-type)|empty|checked|(en|dis)abled|not)(\((.*?)\))?(\b|$|(?=\s|[:+~>]))/ },
3502     { name: 'attrPresence', re: /^\[((?:[\w-]+:)?[\w-]+)\]/ },
3503     { name: 'attr',         re: /\[((?:[\w-]*:)?[\w-]+)\s*(?:([!^$*~|]?=)\s*((['"])([^\4]*?)\4|([^'"][^\]]*?)))?\]/ }
3504   ],
3505
3506   assertions: {
3507     tagName: function(element, matches) {
3508       return matches[1].toUpperCase() == element.tagName.toUpperCase();
3509     },
3510
3511     className: function(element, matches) {
3512       return Element.hasClassName(element, matches[1]);
3513     },
3514
3515     id: function(element, matches) {
3516       return element.id === matches[1];
3517     },
3518
3519     attrPresence: function(element, matches) {
3520       return Element.hasAttribute(element, matches[1]);
3521     },
3522
3523     attr: function(element, matches) {
3524       var nodeValue = Element.readAttribute(element, matches[1]);
3525       return nodeValue && Selector.operators[matches[2]](nodeValue, matches[5] || matches[6]);
3526     }
3527   },
3528
3529   handlers: {
3530     concat: function(a, b) {
3531       for (var i = 0, node; node = b[i]; i++)
3532         a.push(node);
3533       return a;
3534     },
3535
3536     mark: function(nodes) {
3537       var _true = Prototype.emptyFunction;
3538       for (var i = 0, node; node = nodes[i]; i++)
3539         node._countedByPrototype = _true;
3540       return nodes;
3541     },
3542
3543     unmark: (function(){
3544
3545       var PROPERTIES_ATTRIBUTES_MAP = (function(){
3546         var el = document.createElement('div'),
3547             isBuggy = false,
3548             propName = '_countedByPrototype',
3549             value = 'x'
3550         el[propName] = value;
3551         isBuggy = (el.getAttribute(propName) === value);
3552         el = null;
3553         return isBuggy;
3554       })();
3555
3556       return PROPERTIES_ATTRIBUTES_MAP ?
3557         function(nodes) {
3558           for (var i = 0, node; node = nodes[i]; i++)
3559             node.removeAttribute('_countedByPrototype');
3560           return nodes;
3561         } :
3562         function(nodes) {
3563           for (var i = 0, node; node = nodes[i]; i++)
3564             node._countedByPrototype = void 0;
3565           return nodes;
3566         }
3567     })(),
3568
3569     index: function(parentNode, reverse, ofType) {
3570       parentNode._countedByPrototype = Prototype.emptyFunction;
3571       if (reverse) {
3572         for (var nodes = parentNode.childNodes, i = nodes.length - 1, j = 1; i >= 0; i--) {
3573           var node = nodes[i];
3574           if (node.nodeType == 1 && (!ofType || node._countedByPrototype)) node.nodeIndex = j++;
3575         }
3576       } else {
3577         for (var i = 0, j = 1, nodes = parentNode.childNodes; node = nodes[i]; i++)
3578           if (node.nodeType == 1 && (!ofType || node._countedByPrototype)) node.nodeIndex = j++;
3579       }
3580     },
3581
3582     unique: function(nodes) {
3583       if (nodes.length == 0) return nodes;
3584       var results = [], n;
3585       for (var i = 0, l = nodes.length; i < l; i++)
3586         if (typeof (n = nodes[i])._countedByPrototype == 'undefined') {
3587           n._countedByPrototype = Prototype.emptyFunction;
3588           results.push(Element.extend(n));
3589         }
3590       return Selector.handlers.unmark(results);
3591     },
3592
3593     descendant: function(nodes) {
3594       var h = Selector.handlers;
3595       for (var i = 0, results = [], node; node = nodes[i]; i++)
3596         h.concat(results, node.getElementsByTagName('*'));
3597       return results;
3598     },
3599
3600     child: function(nodes) {
3601       var h = Selector.handlers;
3602       for (var i = 0, results = [], node; node = nodes[i]; i++) {
3603         for (var j = 0, child; child = node.childNodes[j]; j++)
3604           if (child.nodeType == 1 && child.tagName != '!') results.push(child);
3605       }
3606       return results;
3607     },
3608
3609     adjacent: function(nodes) {
3610       for (var i = 0, results = [], node; node = nodes[i]; i++) {
3611         var next = this.nextElementSibling(node);
3612         if (next) results.push(next);
3613       }
3614       return results;
3615     },
3616
3617     laterSibling: function(nodes) {
3618       var h = Selector.handlers;
3619       for (var i = 0, results = [], node; node = nodes[i]; i++)
3620         h.concat(results, Element.nextSiblings(node));
3621       return results;
3622     },
3623
3624     nextElementSibling: function(node) {
3625       while (node = node.nextSibling)
3626         if (node.nodeType == 1) return node;
3627       return null;
3628     },
3629
3630     previousElementSibling: function(node) {
3631       while (node = node.previousSibling)
3632         if (node.nodeType == 1) return node;
3633       return null;
3634     },
3635
3636     tagName: function(nodes, root, tagName, combinator) {
3637       var uTagName = tagName.toUpperCase();
3638       var results = [], h = Selector.handlers;
3639       if (nodes) {
3640         if (combinator) {
3641           if (combinator == "descendant") {
3642             for (var i = 0, node; node = nodes[i]; i++)
3643               h.concat(results, node.getElementsByTagName(tagName));
3644             return results;
3645           } else nodes = this[combinator](nodes);
3646           if (tagName == "*") return nodes;
3647         }
3648         for (var i = 0, node; node = nodes[i]; i++)
3649           if (node.tagName.toUpperCase() === uTagName) results.push(node);
3650         return results;
3651       } else return root.getElementsByTagName(tagName);
3652     },
3653
3654     id: function(nodes, root, id, combinator) {
3655       var targetNode = $(id), h = Selector.handlers;
3656
3657       if (root == document) {
3658         if (!targetNode) return [];
3659         if (!nodes) return [targetNode];
3660       } else {
3661         if (!root.sourceIndex || root.sourceIndex < 1) {
3662           var nodes = root.getElementsByTagName('*');
3663           for (var j = 0, node; node = nodes[j]; j++) {
3664             if (node.id === id) return [node];
3665           }
3666         }
3667       }
3668
3669       if (nodes) {
3670         if (combinator) {
3671           if (combinator == 'child') {
3672             for (var i = 0, node; node = nodes[i]; i++)
3673               if (targetNode.parentNode == node) return [targetNode];
3674           } else if (combinator == 'descendant') {
3675             for (var i = 0, node; node = nodes[i]; i++)
3676               if (Element.descendantOf(targetNode, node)) return [targetNode];
3677           } else if (combinator == 'adjacent') {
3678             for (var i = 0, node; node = nodes[i]; i++)
3679               if (Selector.handlers.previousElementSibling(targetNode) == node)
3680                 return [targetNode];
3681           } else nodes = h[combinator](nodes);
3682         }
3683         for (var i = 0, node; node = nodes[i]; i++)
3684           if (node == targetNode) return [targetNode];
3685         return [];
3686       }
3687       return (targetNode && Element.descendantOf(targetNode, root)) ? [targetNode] : [];
3688     },
3689
3690     className: function(nodes, root, className, combinator) {
3691       if (nodes && combinator) nodes = this[combinator](nodes);
3692       return Selector.handlers.byClassName(nodes, root, className);
3693     },
3694
3695     byClassName: function(nodes, root, className) {
3696       if (!nodes) nodes = Selector.handlers.descendant([root]);
3697       var needle = ' ' + className + ' ';
3698       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3699         nodeClassName = node.className;
3700         if (nodeClassName.length == 0) continue;
3701         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3702           results.push(node);
3703       }
3704       return results;
3705     },
3706
3707     attrPresence: function(nodes, root, attr, combinator) {
3708       if (!nodes) nodes = root.getElementsByTagName("*");
3709       if (nodes && combinator) nodes = this[combinator](nodes);
3710       var results = [];
3711       for (var i = 0, node; node = nodes[i]; i++)
3712         if (Element.hasAttribute(node, attr)) results.push(node);
3713       return results;
3714     },
3715
3716     attr: function(nodes, root, attr, value, operator, combinator) {
3717       if (!nodes) nodes = root.getElementsByTagName("*");
3718       if (nodes && combinator) nodes = this[combinator](nodes);
3719       var handler = Selector.operators[operator], results = [];
3720       for (var i = 0, node; node = nodes[i]; i++) {
3721         var nodeValue = Element.readAttribute(node, attr);
3722         if (nodeValue === null) continue;
3723         if (handler(nodeValue, value)) results.push(node);
3724       }
3725       return results;
3726     },
3727
3728     pseudo: function(nodes, name, value, root, combinator) {
3729       if (nodes && combinator) nodes = this[combinator](nodes);
3730       if (!nodes) nodes = root.getElementsByTagName("*");
3731       return Selector.pseudos[name](nodes, value, root);
3732     }
3733   },
3734
3735   pseudos: {
3736     'first-child': function(nodes, value, root) {
3737       for (var i = 0, results = [], node; node = nodes[i]; i++) {
3738         if (Selector.handlers.previousElementSibling(node)) continue;
3739           results.push(node);
3740       }
3741       return results;
3742     },
3743     'last-child': function(nodes, value, root) {
3744       for (var i = 0, results = [], node; node = nodes[i]; i++) {
3745         if (Selector.handlers.nextElementSibling(node)) continue;
3746           results.push(node);
3747       }
3748       return results;
3749     },
3750     'only-child': function(nodes, value, root) {
3751       var h = Selector.handlers;
3752       for (var i = 0, results = [], node; node = nodes[i]; i++)
3753         if (!h.previousElementSibling(node) && !h.nextElementSibling(node))
3754           results.push(node);
3755       return results;
3756     },
3757     'nth-child':        function(nodes, formula, root) {
3758       return Selector.pseudos.nth(nodes, formula, root);
3759     },
3760     'nth-last-child':   function(nodes, formula, root) {
3761       return Selector.pseudos.nth(nodes, formula, root, true);
3762     },
3763     'nth-of-type':      function(nodes, formula, root) {
3764       return Selector.pseudos.nth(nodes, formula, root, false, true);
3765     },
3766     'nth-last-of-type': function(nodes, formula, root) {
3767       return Selector.pseudos.nth(nodes, formula, root, true, true);
3768     },
3769     'first-of-type':    function(nodes, formula, root) {
3770       return Selector.pseudos.nth(nodes, "1", root, false, true);
3771     },
3772     'last-of-type':     function(nodes, formula, root) {
3773       return Selector.pseudos.nth(nodes, "1", root, true, true);
3774     },
3775     'only-of-type':     function(nodes, formula, root) {
3776       var p = Selector.pseudos;
3777       return p['last-of-type'](p['first-of-type'](nodes, formula, root), formula, root);
3778     },
3779
3780     getIndices: function(a, b, total) {
3781       if (a == 0) return b > 0 ? [b] : [];
3782       return $R(1, total).inject([], function(memo, i) {
3783         if (0 == (i - b) % a && (i - b) / a >= 0) memo.push(i);
3784         return memo;
3785       });
3786     },
3787
3788     nth: function(nodes, formula, root, reverse, ofType) {
3789       if (nodes.length == 0) return [];
3790       if (formula == 'even') formula = '2n+0';
3791       if (formula == 'odd')  formula = '2n+1';
3792       var h = Selector.handlers, results = [], indexed = [], m;
3793       h.mark(nodes);
3794       for (var i = 0, node; node = nodes[i]; i++) {
3795         if (!node.parentNode._countedByPrototype) {
3796           h.index(node.parentNode, reverse, ofType);
3797           indexed.push(node.parentNode);
3798         }
3799       }
3800       if (formula.match(/^\d+$/)) { // just a number
3801         formula = Number(formula);
3802         for (var i = 0, node; node = nodes[i]; i++)
3803           if (node.nodeIndex == formula) results.push(node);
3804       } else if (m = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
3805         if (m[1] == "-") m[1] = -1;
3806         var a = m[1] ? Number(m[1]) : 1;
3807         var b = m[2] ? Number(m[2]) : 0;
3808         var indices = Selector.pseudos.getIndices(a, b, nodes.length);
3809         for (var i = 0, node, l = indices.length; node = nodes[i]; i++) {
3810           for (var j = 0; j < l; j++)
3811             if (node.nodeIndex == indices[j]) results.push(node);
3812         }
3813       }
3814       h.unmark(nodes);
3815       h.unmark(indexed);
3816       return results;
3817     },
3818
3819     'empty': function(nodes, value, root) {
3820       for (var i = 0, results = [], node; node = nodes[i]; i++) {
3821         if (node.tagName == '!' || node.firstChild) continue;
3822         results.push(node);
3823       }
3824       return results;
3825     },
3826
3827     'not': function(nodes, selector, root) {
3828       var h = Selector.handlers, selectorType, m;
3829       var exclusions = new Selector(selector).findElements(root);
3830       h.mark(exclusions);
3831       for (var i = 0, results = [], node; node = nodes[i]; i++)
3832         if (!node._countedByPrototype) results.push(node);
3833       h.unmark(exclusions);
3834       return results;
3835     },
3836
3837     'enabled': function(nodes, value, root) {
3838       for (var i = 0, results = [], node; node = nodes[i]; i++)
3839         if (!node.disabled && (!node.type || node.type !== 'hidden'))
3840           results.push(node);
3841       return results;
3842     },
3843
3844     'disabled': function(nodes, value, root) {
3845       for (var i = 0, results = [], node; node = nodes[i]; i++)
3846         if (node.disabled) results.push(node);
3847       return results;
3848     },
3849
3850     'checked': function(nodes, value, root) {
3851       for (var i = 0, results = [], node; node = nodes[i]; i++)
3852         if (node.checked) results.push(node);
3853       return results;
3854     }
3855   },
3856
3857   operators: {
3858     '=':  function(nv, v) { return nv == v; },
3859     '!=': function(nv, v) { return nv != v; },
3860     '^=': function(nv, v) { return nv == v || nv && nv.startsWith(v); },
3861     '$=': function(nv, v) { return nv == v || nv && nv.endsWith(v); },
3862     '*=': function(nv, v) { return nv == v || nv && nv.include(v); },
3863     '~=': function(nv, v) { return (' ' + nv + ' ').include(' ' + v + ' '); },
3864     '|=': function(nv, v) { return ('-' + (nv || "").toUpperCase() +
3865      '-').include('-' + (v || "").toUpperCase() + '-'); }
3866   },
3867
3868   split: function(expression) {
3869     var expressions = [];
3870     expression.scan(/(([\w#:.~>+()\s-]+|\*|\[.*?\])+)\s*(,|$)/, function(m) {
3871       expressions.push(m[1].strip());
3872     });
3873     return expressions;
3874   },
3875
3876   matchElements: function(elements, expression) {
3877     var matches = $$(expression), h = Selector.handlers;
3878     h.mark(matches);
3879     for (var i = 0, results = [], element; element = elements[i]; i++)
3880       if (element._countedByPrototype) results.push(element);
3881     h.unmark(matches);
3882     return results;
3883   },
3884
3885   findElement: function(elements, expression, index) {
3886     if (Object.isNumber(expression)) {
3887       index = expression; expression = false;
3888     }
3889     return Selector.matchElements(elements, expression || '*')[index || 0];
3890   },
3891
3892   findChildElements: function(element, expressions) {
3893     expressions = Selector.split(expressions.join(','));
3894     var results = [], h = Selector.handlers;
3895     for (var i = 0, l = expressions.length, selector; i < l; i++) {
3896       selector = new Selector(expressions[i].strip());
3897       h.concat(results, selector.findElements(element));
3898     }
3899     return (l > 1) ? h.unique(results) : results;
3900   }
3901 });
3902
3903 if (Prototype.Browser.IE) {
3904   Object.extend(Selector.handlers, {
3905     concat: function(a, b) {
3906       for (var i = 0, node; node = b[i]; i++)
3907         if (node.tagName !== "!") a.push(node);
3908       return a;
3909     }
3910   });
3911 }
3912
3913 function $$() {
3914   return Selector.findChildElements(document, $A(arguments));
3915 }
3916
3917 var Form = {
3918   reset: function(form) {
3919     form = $(form);
3920     form.reset();
3921     return form;
3922   },
3923
3924   serializeElements: function(elements, options) {
3925     if (typeof options != 'object') options = { hash: !!options };
3926     else if (Object.isUndefined(options.hash)) options.hash = true;
3927     var key, value, submitted = false, submit = options.submit;
3928
3929     var data = elements.inject({ }, function(result, element) {
3930       if (!element.disabled && element.name) {
3931         key = element.name; value = $(element).getValue();
3932         if (value != null && element.type != 'file' && (element.type != 'submit' || (!submitted &&
3933             submit !== false && (!submit || key == submit) && (submitted = true)))) {
3934           if (key in result) {
3935             if (!Object.isArray(result[key])) result[key] = [result[key]];
3936             result[key].push(value);
3937           }
3938           else result[key] = value;
3939         }
3940       }
3941       return result;
3942     });
3943
3944     return options.hash ? data : Object.toQueryString(data);
3945   }
3946 };
3947
3948 Form.Methods = {
3949   serialize: function(form, options) {
3950     return Form.serializeElements(Form.getElements(form), options);
3951   },
3952
3953   getElements: function(form) {
3954     var elements = $(form).getElementsByTagName('*'),
3955         element,
3956         arr = [ ],
3957         serializers = Form.Element.Serializers;
3958     for (var i = 0; element = elements[i]; i++) {
3959       arr.push(element);
3960     }
3961     return arr.inject([], function(elements, child) {
3962       if (serializers[child.tagName.toLowerCase()])
3963         elements.push(Element.extend(child));
3964       return elements;
3965     })
3966   },
3967
3968   getInputs: function(form, typeName, name) {
3969     form = $(form);
3970     var inputs = form.getElementsByTagName('input');
3971
3972     if (!typeName && !name) return $A(inputs).map(Element.extend);
3973
3974     for (var i = 0, matchingInputs = [], length = inputs.length; i < length; i++) {
3975       var input = inputs[i];
3976       if ((typeName && input.type != typeName) || (name && input.name != name))
3977         continue;
3978       matchingInputs.push(Element.extend(input));
3979     }
3980
3981     return matchingInputs;
3982   },
3983
3984   disable: function(form) {
3985     form = $(form);
3986     Form.getElements(form).invoke('disable');
3987     return form;
3988   },
3989
3990   enable: function(form) {
3991     form = $(form);
3992     Form.getElements(form).invoke('enable');
3993     return form;
3994   },
3995
3996   findFirstElement: function(form) {
3997     var elements = $(form).getElements().findAll(function(element) {
3998       return 'hidden' != element.type && !element.disabled;
3999     });
4000     var firstByIndex = elements.findAll(function(element) {
4001       return element.hasAttribute('tabIndex') && element.tabIndex >= 0;
4002     }).sortBy(function(element) { return element.tabIndex }).first();
4003
4004     return firstByIndex ? firstByIndex : elements.find(function(element) {
4005       return /^(?:input|select|textarea)$/i.test(element.tagName);
4006     });
4007   },
4008
4009   focusFirstElement: function(form) {
4010     form = $(form);
4011     form.findFirstElement().activate();
4012     return form;
4013   },
4014
4015   request: function(form, options) {
4016     form = $(form), options = Object.clone(options || { });
4017
4018     var params = options.parameters, action = form.readAttribute('action') || '';
4019     if (action.blank()) action = window.location.href;
4020     options.parameters = form.serialize(true);
4021
4022     if (params) {
4023       if (Object.isString(params)) params = params.toQueryParams();
4024       Object.extend(options.parameters, params);
4025     }
4026
4027     if (form.hasAttribute('method') && !options.method)
4028       options.method = form.method;
4029
4030     return new Ajax.Request(action, options);
4031   }
4032 };
4033
4034 /*--------------------------------------------------------------------------*/
4035
4036
4037 Form.Element = {
4038   focus: function(element) {
4039     $(element).focus();
4040     return element;
4041   },
4042
4043   select: function(element) {
4044     $(element).select();
4045     return element;
4046   }
4047 };
4048
4049 Form.Element.Methods = {
4050
4051   serialize: function(element) {
4052     element = $(element);
4053     if (!element.disabled && element.name) {
4054       var value = element.getValue();
4055       if (value != undefined) {
4056         var pair = { };
4057         pair[element.name] = value;
4058         return Object.toQueryString(pair);
4059       }
4060     }
4061     return '';
4062   },
4063
4064   getValue: function(element) {
4065     element = $(element);
4066     var method = element.tagName.toLowerCase();
4067     return Form.Element.Serializers[method](element);
4068   },
4069
4070   setValue: function(element, value) {
4071     element = $(element);
4072     var method = element.tagName.toLowerCase();
4073     Form.Element.Serializers[method](element, value);
4074     return element;
4075   },
4076
4077   clear: function(element) {
4078     $(element).value = '';
4079     return element;
4080   },
4081
4082   present: function(element) {
4083     return $(element).value != '';
4084   },
4085
4086   activate: function(element) {
4087     element = $(element);
4088     try {
4089       element.focus();
4090       if (element.select && (element.tagName.toLowerCase() != 'input' ||
4091           !(/^(?:button|reset|submit)$/i.test(element.type))))
4092         element.select();
4093     } catch (e) { }
4094     return element;
4095   },
4096
4097   disable: function(element) {
4098     element = $(element);
4099     element.disabled = true;
4100     return element;
4101   },
4102
4103   enable: function(element) {
4104     element = $(element);
4105     element.disabled = false;
4106     return element;
4107   }
4108 };
4109
4110 /*--------------------------------------------------------------------------*/
4111
4112 var Field = Form.Element;
4113
4114 var $F = Form.Element.Methods.getValue;
4115
4116 /*--------------------------------------------------------------------------*/
4117
4118 Form.Element.Serializers = {
4119   input: function(element, value) {
4120     switch (element.type.toLowerCase()) {
4121       case 'checkbox':
4122       case 'radio':
4123         return Form.Element.Serializers.inputSelector(element, value);
4124       default:
4125         return Form.Element.Serializers.textarea(element, value);
4126     }
4127   },
4128
4129   inputSelector: function(element, value) {
4130     if (Object.isUndefined(value)) return element.checked ? element.value : null;
4131     else element.checked = !!value;
4132   },
4133
4134   textarea: function(element, value) {
4135     if (Object.isUndefined(value)) return element.value;
4136     else element.value = value;
4137   },
4138
4139   select: function(element, value) {
4140     if (Object.isUndefined(value))
4141       return this[element.type == 'select-one' ?
4142         'selectOne' : 'selectMany'](element);
4143     else {
4144       var opt, currentValue, single = !Object.isArray(value);
4145       for (var i = 0, length = element.length; i < length; i++) {
4146         opt = element.options[i];
4147         currentValue = this.optionValue(opt);
4148         if (single) {
4149           if (currentValue == value) {
4150             opt.selected = true;
4151             return;
4152           }
4153         }
4154         else opt.selected = value.include(currentValue);
4155       }
4156     }
4157   },
4158
4159   selectOne: function(element) {
4160     var index = element.selectedIndex;
4161     return index >= 0 ? this.optionValue(element.options[index]) : null;
4162   },
4163
4164   selectMany: function(element) {
4165     var values, length = element.length;
4166     if (!length) return null;
4167
4168     for (var i = 0, values = []; i < length; i++) {
4169       var opt = element.options[i];
4170       if (opt.selected) values.push(this.optionValue(opt));
4171     }
4172     return values;
4173   },
4174
4175   optionValue: function(opt) {
4176     return Element.extend(opt).hasAttribute('value') ? opt.value : opt.text;
4177   }
4178 };
4179
4180 /*--------------------------------------------------------------------------*/
4181
4182
4183 Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
4184   initialize: function($super, element, frequency, callback) {
4185     $super(callback, frequency);
4186     this.element   = $(element);
4187     this.lastValue = this.getValue();
4188   },
4189
4190   execute: function() {
4191     var value = this.getValue();
4192     if (Object.isString(this.lastValue) && Object.isString(value) ?
4193         this.lastValue != value : String(this.lastValue) != String(value)) {
4194       this.callback(this.element, value);
4195       this.lastValue = value;
4196     }
4197   }
4198 });
4199
4200 Form.Element.Observer = Class.create(Abstract.TimedObserver, {
4201   getValue: function() {
4202     return Form.Element.getValue(this.element);
4203   }
4204 });
4205
4206 Form.Observer = Class.create(Abstract.TimedObserver, {
4207   getValue: function() {
4208     return Form.serialize(this.element);
4209   }
4210 });
4211
4212 /*--------------------------------------------------------------------------*/
4213
4214 Abstract.EventObserver = Class.create({
4215   initialize: function(element, callback) {
4216     this.element  = $(element);
4217     this.callback = callback;
4218
4219     this.lastValue = this.getValue();
4220     if (this.element.tagName.toLowerCase() == 'form')
4221       this.registerFormCallbacks();
4222     else
4223       this.registerCallback(this.element);
4224   },
4225
4226   onElementEvent: function() {
4227     var value = this.getValue();
4228     if (this.lastValue != value) {
4229       this.callback(this.element, value);
4230       this.lastValue = value;
4231     }
4232   },
4233
4234   registerFormCallbacks: function() {
4235     Form.getElements(this.element).each(this.registerCallback, this);
4236   },
4237
4238   registerCallback: function(element) {
4239     if (element.type) {
4240       switch (element.type.toLowerCase()) {
4241         case 'checkbox':
4242         case 'radio':
4243           Event.observe(element, 'click', this.onElementEvent.bind(this));
4244           break;
4245         default:
4246           Event.observe(element, 'change', this.onElementEvent.bind(this));
4247           break;
4248       }
4249     }
4250   }
4251 });
4252
4253 Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
4254   getValue: function() {
4255     return Form.Element.getValue(this.element);
4256   }
4257 });
4258
4259 Form.EventObserver = Class.create(Abstract.EventObserver, {
4260   getValue: function() {
4261     return Form.serialize(this.element);
4262   }
4263 });
4264 (function() {
4265
4266   var Event = {
4267     KEY_BACKSPACE: 8,
4268     KEY_TAB:       9,
4269     KEY_RETURN:   13,
4270     KEY_ESC:      27,
4271     KEY_LEFT:     37,
4272     KEY_UP:       38,
4273     KEY_RIGHT:    39,
4274     KEY_DOWN:     40,
4275     KEY_DELETE:   46,
4276     KEY_HOME:     36,
4277     KEY_END:      35,
4278     KEY_PAGEUP:   33,
4279     KEY_PAGEDOWN: 34,
4280     KEY_INSERT:   45,
4281
4282     cache: {}
4283   };
4284
4285   var docEl = document.documentElement;
4286   var MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED = 'onmouseenter' in docEl
4287     && 'onmouseleave' in docEl;
4288
4289   var _isButton;
4290   if (Prototype.Browser.IE) {
4291     var buttonMap = { 0: 1, 1: 4, 2: 2 };
4292     _isButton = function(event, code) {
4293       return event.button === buttonMap[code];
4294     };
4295   } else if (Prototype.Browser.WebKit) {
4296     _isButton = function(event, code) {
4297       switch (code) {
4298         case 0: return event.which == 1 && !event.metaKey;
4299         case 1: return event.which == 1 && event.metaKey;
4300         default: return false;
4301       }
4302     };
4303   } else {
4304     _isButton = function(event, code) {
4305       return event.which ? (event.which === code + 1) : (event.button === code);
4306     };
4307   }
4308
4309   function isLeftClick(event)   { return _isButton(event, 0) }
4310
4311   function isMiddleClick(event) { return _isButton(event, 1) }
4312
4313   function isRightClick(event)  { return _isButton(event, 2) }
4314
4315   function element(event) {
4316     event = Event.extend(event);
4317
4318     var node = event.target, type = event.type,
4319      currentTarget = event.currentTarget;
4320
4321     if (currentTarget && currentTarget.tagName) {
4322       if (type === 'load' || type === 'error' ||
4323         (type === 'click' && currentTarget.tagName.toLowerCase() === 'input'
4324           && currentTarget.type === 'radio'))
4325             node = currentTarget;
4326     }
4327
4328     if (node.nodeType == Node.TEXT_NODE)
4329       node = node.parentNode;
4330
4331     return Element.extend(node);
4332   }
4333
4334   function findElement(event, expression) {
4335     var element = Event.element(event);
4336     if (!expression) return element;
4337     var elements = [element].concat(element.ancestors());
4338     return Selector.findElement(elements, expression, 0);
4339   }
4340
4341   function pointer(event) {
4342     return { x: pointerX(event), y: pointerY(event) };
4343   }
4344
4345   function pointerX(event) {
4346     var docElement = document.documentElement,
4347      body = document.body || { scrollLeft: 0 };
4348
4349     return event.pageX || (event.clientX +
4350       (docElement.scrollLeft || body.scrollLeft) -
4351       (docElement.clientLeft || 0));
4352   }
4353
4354   function pointerY(event) {
4355     var docElement = document.documentElement,
4356      body = document.body || { scrollTop: 0 };
4357
4358     return  event.pageY || (event.clientY +
4359        (docElement.scrollTop || body.scrollTop) -
4360        (docElement.clientTop || 0));
4361   }
4362
4363
4364   function stop(event) {
4365     Event.extend(event);
4366     event.preventDefault();
4367     event.stopPropagation();
4368
4369     event.stopped = true;
4370   }
4371
4372   Event.Methods = {
4373     isLeftClick: isLeftClick,
4374     isMiddleClick: isMiddleClick,
4375     isRightClick: isRightClick,
4376
4377     element: element,
4378     findElement: findElement,
4379
4380     pointer: pointer,
4381     pointerX: pointerX,
4382     pointerY: pointerY,
4383
4384     stop: stop
4385   };
4386
4387
4388   var methods = Object.keys(Event.Methods).inject({ }, function(m, name) {
4389     m[name] = Event.Methods[name].methodize();
4390     return m;
4391   });
4392
4393   if (Prototype.Browser.IE) {
4394     function _relatedTarget(event) {
4395       var element;
4396       switch (event.type) {
4397         case 'mouseover': element = event.fromElement; break;
4398         case 'mouseout':  element = event.toElement;   break;
4399         default: return null;
4400       }
4401       return Element.extend(element);
4402     }
4403
4404     Object.extend(methods, {
4405       stopPropagation: function() { this.cancelBubble = true },
4406       preventDefault:  function() { this.returnValue = false },
4407       inspect: function() { return '[object Event]' }
4408     });
4409
4410     Event.extend = function(event, element) {
4411       if (!event) return false;
4412       if (event._extendedByPrototype) return event;
4413
4414       event._extendedByPrototype = Prototype.emptyFunction;
4415       var pointer = Event.pointer(event);
4416
4417       Object.extend(event, {
4418         target: event.srcElement || element,
4419         relatedTarget: _relatedTarget(event),
4420         pageX:  pointer.x,
4421         pageY:  pointer.y
4422       });
4423
4424       return Object.extend(event, methods);
4425     };
4426   } else {
4427     Event.prototype = window.Event.prototype || document.createEvent('HTMLEvents').__proto__;
4428     Object.extend(Event.prototype, methods);
4429     Event.extend = Prototype.K;
4430   }
4431
4432   function _createResponder(element, eventName, handler) {
4433     var registry = Element.retrieve(element, 'prototype_event_registry');
4434
4435     if (Object.isUndefined(registry)) {
4436       CACHE.push(element);
4437       registry = Element.retrieve(element, 'prototype_event_registry', $H());
4438     }
4439
4440     var respondersForEvent = registry.get(eventName);
4441     if (Object.isUndefined(respondersForEvent)) {
4442       respondersForEvent = [];
4443       registry.set(eventName, respondersForEvent);
4444     }
4445
4446     if (respondersForEvent.pluck('handler').include(handler)) return false;
4447
4448     var responder;
4449     if (eventName.include(":")) {
4450       responder = function(event) {
4451         if (Object.isUndefined(event.eventName))
4452           return false;
4453
4454         if (event.eventName !== eventName)
4455           return false;
4456
4457         Event.extend(event, element);
4458         handler.call(element, event);
4459       };
4460     } else {
4461       if (!MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED &&
4462        (eventName === "mouseenter" || eventName === "mouseleave")) {
4463         if (eventName === "mouseenter" || eventName === "mouseleave") {
4464           responder = function(event) {
4465             Event.extend(event, element);
4466
4467             var parent = event.relatedTarget;
4468             while (parent && parent !== element) {
4469               try { parent = parent.parentNode; }
4470               catch(e) { parent = element; }
4471             }
4472
4473             if (parent === element) return;
4474
4475             handler.call(element, event);
4476           };
4477         }
4478       } else {
4479         responder = function(event) {
4480           Event.extend(event, element);
4481           handler.call(element, event);
4482         };
4483       }
4484     }
4485
4486     responder.handler = handler;
4487     respondersForEvent.push(responder);
4488     return responder;
4489   }
4490
4491   function _destroyCache() {
4492     for (var i = 0, length = CACHE.length; i < length; i++) {
4493       Event.stopObserving(CACHE[i]);
4494       CACHE[i] = null;
4495     }
4496   }
4497
4498   var CACHE = [];
4499
4500   if (Prototype.Browser.IE)
4501     window.attachEvent('onunload', _destroyCache);
4502
4503   if (Prototype.Browser.WebKit)
4504     window.addEventListener('unload', Prototype.emptyFunction, false);
4505
4506
4507   var _getDOMEventName = Prototype.K;
4508
4509   if (!MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED) {
4510     _getDOMEventName = function(eventName) {
4511       var translations = { mouseenter: "mouseover", mouseleave: "mouseout" };
4512       return eventName in translations ? translations[eventName] : eventName;
4513     };
4514   }
4515
4516   function observe(element, eventName, handler) {
4517     element = $(element);
4518
4519     var responder = _createResponder(element, eventName, handler);
4520
4521     if (!responder) return element;
4522
4523     if (eventName.include(':')) {
4524       if (element.addEventListener)
4525         element.addEventListener("dataavailable", responder, false);
4526       else {
4527         element.attachEvent("ondataavailable", responder);
4528         element.attachEvent("onfilterchange", responder);
4529       }
4530     } else {
4531       var actualEventName = _getDOMEventName(eventName);
4532
4533       if (element.addEventListener)
4534         element.addEventListener(actualEventName, responder, false);
4535       else
4536         element.attachEvent("on" + actualEventName, responder);
4537     }
4538
4539     return element;
4540   }
4541
4542   function stopObserving(element, eventName, handler) {
4543     element = $(element);
4544
4545     var registry = Element.retrieve(element, 'prototype_event_registry');
4546
4547     if (Object.isUndefined(registry)) return element;
4548
4549     if (eventName && !handler) {
4550       var responders = registry.get(eventName);
4551
4552       if (Object.isUndefined(responders)) return element;
4553
4554       responders.each( function(r) {
4555         Element.stopObserving(element, eventName, r.handler);
4556       });
4557       return element;
4558     } else if (!eventName) {
4559       registry.each( function(pair) {
4560         var eventName = pair.key, responders = pair.value;
4561
4562         responders.each( function(r) {
4563           Element.stopObserving(element, eventName, r.handler);
4564         });
4565       });
4566       return element;
4567     }
4568
4569     var responders = registry.get(eventName);
4570
4571     if (!responders) return;
4572
4573     var responder = responders.find( function(r) { return r.handler === handler; });
4574     if (!responder) return element;
4575
4576     var actualEventName = _getDOMEventName(eventName);
4577
4578     if (eventName.include(':')) {
4579       if (element.removeEventListener)
4580         element.removeEventListener("dataavailable", responder, false);
4581       else {
4582         element.detachEvent("ondataavailable", responder);
4583         element.detachEvent("onfilterchange",  responder);
4584       }
4585     } else {
4586       if (element.removeEventListener)
4587         element.removeEventListener(actualEventName, responder, false);
4588       else
4589         element.detachEvent('on' + actualEventName, responder);
4590     }
4591
4592     registry.set(eventName, responders.without(responder));
4593
4594     return element;
4595   }
4596
4597   function fire(element, eventName, memo, bubble) {
4598     element = $(element);
4599
4600     if (Object.isUndefined(bubble))
4601       bubble = true;
4602
4603     if (element == document && document.createEvent && !element.dispatchEvent)
4604       element = document.documentElement;
4605
4606     var event;
4607     if (document.createEvent) {
4608       event = document.createEvent('HTMLEvents');
4609       event.initEvent('dataavailable', true, true);
4610     } else {
4611       event = document.createEventObject();
4612       event.eventType = bubble ? 'ondataavailable' : 'onfilterchange';
4613     }
4614
4615     event.eventName = eventName;
4616     event.memo = memo || { };
4617
4618     if (document.createEvent)
4619       element.dispatchEvent(event);
4620     else
4621       element.fireEvent(event.eventType, event);
4622
4623     return Event.extend(event);
4624   }
4625
4626
4627   Object.extend(Event, Event.Methods);
4628
4629   Object.extend(Event, {
4630     fire:          fire,
4631     observe:       observe,
4632     stopObserving: stopObserving
4633   });
4634
4635   Element.addMethods({
4636     fire:          fire,
4637
4638     observe:       observe,
4639
4640     stopObserving: stopObserving
4641   });
4642
4643   Object.extend(document, {
4644     fire:          fire.methodize(),
4645
4646     observe:       observe.methodize(),
4647
4648     stopObserving: stopObserving.methodize(),
4649
4650     loaded:        false
4651   });
4652
4653   if (window.Event) Object.extend(window.Event, Event);
4654   else window.Event = Event;
4655 })();
4656
4657 (function() {
4658   /* Support for the DOMContentLoaded event is based on work by Dan Webb,
4659      Matthias Miller, Dean Edwards, John Resig, and Diego Perini. */
4660
4661   var timer;
4662
4663   function fireContentLoadedEvent() {
4664     if (document.loaded) return;
4665     if (timer) window.clearTimeout(timer);
4666     document.loaded = true;
4667     document.fire('dom:loaded');
4668   }
4669
4670   function checkReadyState() {
4671     if (document.readyState === 'complete') {
4672       document.stopObserving('readystatechange', checkReadyState);
4673       fireContentLoadedEvent();
4674     }
4675   }
4676
4677   function pollDoScroll() {
4678     try { document.documentElement.doScroll('left'); }
4679     catch(e) {
4680       timer = pollDoScroll.defer();
4681       return;
4682     }
4683     fireContentLoadedEvent();
4684   }
4685
4686   if (document.addEventListener) {
4687     document.addEventListener('DOMContentLoaded', fireContentLoadedEvent, false);
4688   } else {
4689     document.observe('readystatechange', checkReadyState);
4690     if (window == top)
4691       timer = pollDoScroll.defer();
4692   }
4693
4694   Event.observe(window, 'load', fireContentLoadedEvent);
4695 })();
4696
4697 Element.addMethods();
4698
4699 /*------------------------------- DEPRECATED -------------------------------*/
4700
4701 Hash.toQueryString = Object.toQueryString;
4702
4703 var Toggle = { display: Element.toggle };
4704
4705 Element.Methods.childOf = Element.Methods.descendantOf;
4706
4707 var Insertion = {
4708   Before: function(element, content) {
4709     return Element.insert(element, {before:content});
4710   },
4711
4712   Top: function(element, content) {
4713     return Element.insert(element, {top:content});
4714   },
4715
4716   Bottom: function(element, content) {
4717     return Element.insert(element, {bottom:content});
4718   },
4719
4720   After: function(element, content) {
4721     return Element.insert(element, {after:content});
4722   }
4723 };
4724
4725 var $continue = new Error('"throw $continue" is deprecated, use "return" instead');
4726
4727 var Position = {
4728   includeScrollOffsets: false,
4729
4730   prepare: function() {
4731     this.deltaX =  window.pageXOffset
4732                 || document.documentElement.scrollLeft
4733                 || document.body.scrollLeft
4734                 || 0;
4735     this.deltaY =  window.pageYOffset
4736                 || document.documentElement.scrollTop
4737                 || document.body.scrollTop
4738                 || 0;
4739   },
4740
4741   within: function(element, x, y) {
4742     if (this.includeScrollOffsets)
4743       return this.withinIncludingScrolloffsets(element, x, y);
4744     this.xcomp = x;
4745     this.ycomp = y;
4746     this.offset = Element.cumulativeOffset(element);
4747
4748     return (y >= this.offset[1] &&
4749             y <  this.offset[1] + element.offsetHeight &&
4750             x >= this.offset[0] &&
4751             x <  this.offset[0] + element.offsetWidth);
4752   },
4753
4754   withinIncludingScrolloffsets: function(element, x, y) {
4755     var offsetcache = Element.cumulativeScrollOffset(element);
4756
4757     this.xcomp = x + offsetcache[0] - this.deltaX;
4758     this.ycomp = y + offsetcache[1] - this.deltaY;
4759     this.offset = Element.cumulativeOffset(element);
4760
4761     return (this.ycomp >= this.offset[1] &&
4762             this.ycomp <  this.offset[1] + element.offsetHeight &&
4763             this.xcomp >= this.offset[0] &&
4764             this.xcomp <  this.offset[0] + element.offsetWidth);
4765   },
4766
4767   overlap: function(mode, element) {
4768     if (!mode) return 0;
4769     if (mode == 'vertical')
4770       return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
4771         element.offsetHeight;
4772     if (mode == 'horizontal')
4773       return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
4774         element.offsetWidth;
4775   },
4776
4777
4778   cumulativeOffset: Element.Methods.cumulativeOffset,
4779
4780   positionedOffset: Element.Methods.positionedOffset,
4781
4782   absolutize: function(element) {
4783     Position.prepare();
4784     return Element.absolutize(element);
4785   },
4786
4787   relativize: function(element) {
4788     Position.prepare();
4789     return Element.relativize(element);
4790   },
4791
4792   realOffset: Element.Methods.cumulativeScrollOffset,
4793
4794   offsetParent: Element.Methods.getOffsetParent,
4795
4796   page: Element.Methods.viewportOffset,
4797
4798   clone: function(source, target, options) {
4799     options = options || { };
4800     return Element.clonePosition(target, source, options);
4801   }
4802 };
4803
4804 /*--------------------------------------------------------------------------*/
4805
4806 if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4807   function iter(name) {
4808     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4809   }
4810
4811   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
4812   function(element, className) {
4813     className = className.toString().strip();
4814     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4815     return cond ? document._getElementsByXPath('.//*' + cond, element) : [];
4816   } : function(element, className) {
4817     className = className.toString().strip();
4818     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4819     if (!classNames && !className) return elements;
4820
4821     var nodes = $(element).getElementsByTagName('*');
4822     className = ' ' + className + ' ';
4823
4824     for (var i = 0, child, cn; child = nodes[i]; i++) {
4825       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4826           (classNames && classNames.all(function(name) {
4827             return !name.toString().blank() && cn.include(' ' + name + ' ');
4828           }))))
4829         elements.push(Element.extend(child));
4830     }
4831     return elements;
4832   };
4833
4834   return function(className, parentElement) {
4835     return $(parentElement || document.body).getElementsByClassName(className);
4836   };
4837 }(Element.Methods);
4838
4839 /*--------------------------------------------------------------------------*/
4840
4841 Element.ClassNames = Class.create();
4842 Element.ClassNames.prototype = {
4843   initialize: function(element) {
4844     this.element = $(element);
4845   },
4846
4847   _each: function(iterator) {
4848     this.element.className.split(/\s+/).select(function(name) {
4849       return name.length > 0;
4850     })._each(iterator);
4851   },
4852
4853   set: function(className) {
4854     this.element.className = className;
4855   },
4856
4857   add: function(classNameToAdd) {
4858     if (this.include(classNameToAdd)) return;
4859     this.set($A(this).concat(classNameToAdd).join(' '));
4860   },
4861
4862   remove: function(classNameToRemove) {
4863     if (!this.include(classNameToRemove)) return;
4864     this.set($A(this).without(classNameToRemove).join(' '));
4865   },
4866
4867   toString: function() {
4868     return $A(this).join(' ');
4869   }
4870 };
4871
4872 Object.extend(Element.ClassNames.prototype, Enumerable);
4873
4874 /*--------------------------------------------------------------------------*/