1 /*  Prototype JavaScript framework, version 1.6.0.1

     2  *  (c) 2005-2007 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.0.1',

    11 

    12   Browser: {

    13     IE:     !!(window.attachEvent && !window.opera),

    14     Opera:  !!window.opera,

    15     WebKit: navigator.userAgent.indexOf('AppleWebKit/') > -1,

    16     Gecko:  navigator.userAgent.indexOf('Gecko') > -1 && navigator.userAgent.indexOf('KHTML') == -1,

    17     MobileSafari: !!navigator.userAgent.match(/Apple.*Mobile.*Safari/)

    18   },

    19 

    20   BrowserFeatures: {

    21     XPath: !!document.evaluate,

    22     ElementExtensions: !!window.HTMLElement,

    23     SpecificElementExtensions:

    24       document.createElement('div').__proto__ &&

    25       document.createElement('div').__proto__ !==

    26         document.createElement('form').__proto__

    27   },

    28 

    29   ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',

    30   JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,

    31 

    32   emptyFunction: function() { },

    33   K: function(x) { return x }

    34 };

    35 

    36 if (Prototype.Browser.MobileSafari)

    37   Prototype.BrowserFeatures.SpecificElementExtensions = false;

    38 

    39 

    40 /* Based on Alex Arnell's inheritance implementation. */

    41 var Class = {

    42   create: function() {

    43     var parent = null, properties = $A(arguments);

    44     if (Object.isFunction(properties[0]))

    45       parent = properties.shift();

    46 

    47     function klass() {

    48       this.initialize.apply(this, arguments);

    49     }

    50 

    51     Object.extend(klass, Class.Methods);

    52     klass.superclass = parent;

    53     klass.subclasses = [];

    54 

    55     if (parent) {

    56       var subclass = function() { };

    57       subclass.prototype = parent.prototype;

    58       klass.prototype = new subclass;

    59       parent.subclasses.push(klass);

    60     }

    61 

    62     for (var i = 0; i < properties.length; i++)

    63       klass.addMethods(properties[i]);

    64 

    65     if (!klass.prototype.initialize)

    66       klass.prototype.initialize = Prototype.emptyFunction;

    67 

    68     klass.prototype.constructor = klass;

    69 

    70     return klass;

    71   }

    72 };

    73 

    74 Class.Methods = {

    75   addMethods: function(source) {

    76     var ancestor   = this.superclass && this.superclass.prototype;

    77     var properties = Object.keys(source);

    78 

    79     if (!Object.keys({ toString: true }).length)

    80       properties.push("toString", "valueOf");

    81 

    82     for (var i = 0, length = properties.length; i < length; i++) {

    83       var property = properties[i], value = source[property];

    84       if (ancestor && Object.isFunction(value) &&

    85           value.argumentNames().first() == "$super") {

    86         var method = value, value = Object.extend((function(m) {

    87           return function() { return ancestor[m].apply(this, arguments) };

    88         })(property).wrap(method), {

    89           valueOf:  function() { return method },

    90           toString: function() { return method.toString() }

    91         });

    92       }

    93       this.prototype[property] = value;

    94     }

    95 

    96     return this;

    97   }

    98 };

    99 

   100 var Abstract = { };

   101 

   102 Object.extend = function(destination, source) {

   103   for (var property in source)

   104     destination[property] = source[property];

   105   return destination;

   106 };

   107 

   108 Object.extend(Object, {

   109   inspect: function(object) {

   110     try {

   111       if (Object.isUndefined(object)) return 'undefined';

   112       if (object === null) return 'null';

   113       return object.inspect ? object.inspect() : object.toString();

   114     } catch (e) {

   115       if (e instanceof RangeError) return '...';

   116       throw e;

   117     }

   118   },

   119 

   120   toJSON: function(object) {

   121     var type = typeof object;

   122     switch (type) {

   123       case 'undefined':

   124       case 'function':

   125       case 'unknown': return;

   126       case 'boolean': return object.toString();

   127     }

   128 

   129     if (object === null) return 'null';

   130     if (object.toJSON) return object.toJSON();

   131     if (Object.isElement(object)) return;

   132 

   133     var results = [];

   134     for (var property in object) {

   135       var value = Object.toJSON(object[property]);

   136       if (!Object.isUndefined(value))

   137         results.push(property.toJSON() + ': ' + value);

   138     }

   139 

   140     return '{' + results.join(', ') + '}';

   141   },

   142 

   143   toQueryString: function(object) {

   144     return $H(object).toQueryString();

   145   },

   146 

   147   toHTML: function(object) {

   148     return object && object.toHTML ? object.toHTML() : String.interpret(object);

   149   },

   150 

   151   keys: function(object) {

   152     var keys = [];

   153     for (var property in object)

   154       keys.push(property);

   155     return keys;

   156   },

   157 

   158   values: function(object) {

   159     var values = [];

   160     for (var property in object)

   161       values.push(object[property]);

   162     return values;

   163   },

   164 

   165   clone: function(object) {

   166     return Object.extend({ }, object);

   167   },

   168 

   169   isElement: function(object) {

   170     return object && object.nodeType == 1;

   171   },

   172 

   173   isArray: function(object) {

   174     return object && object.constructor === Array;

   175   },

   176 

   177   isHash: function(object) {

   178     return object instanceof Hash;

   179   },

   180 

   181   isFunction: function(object) {

   182     return typeof object == "function";

   183   },

   184 

   185   isString: function(object) {

   186     return typeof object == "string";

   187   },

   188 

   189   isNumber: function(object) {

   190     return typeof object == "number";

   191   },

   192 

   193   isUndefined: function(object) {

   194     return typeof object == "undefined";

   195   }

   196 });

   197 

   198 Object.extend(Function.prototype, {

   199   argumentNames: function() {

   200     var names = this.toString().match(/^[\s\(]*function[^(]*\((.*?)\)/)[1].split(",").invoke("strip");

   201     return names.length == 1 && !names[0] ? [] : names;

   202   },

   203 

   204   bind: function() {

   205     if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;

   206     var __method = this, args = $A(arguments), object = args.shift();

   207     return function() {

   208       return __method.apply(object, args.concat($A(arguments)));

   209     }

   210   },

   211 

   212   bindAsEventListener: function() {

   213     var __method = this, args = $A(arguments), object = args.shift();

   214     return function(event) {

   215       return __method.apply(object, [event || window.event].concat(args));

   216     }

   217   },

   218 

   219   curry: function() {

   220     if (!arguments.length) return this;

   221     var __method = this, args = $A(arguments);

   222     return function() {

   223       return __method.apply(this, args.concat($A(arguments)));

   224     }

   225   },

   226 

   227   delay: function() {

   228     var __method = this, args = $A(arguments), timeout = args.shift() * 1000;

   229     return window.setTimeout(function() {

   230       return __method.apply(__method, args);

   231     }, timeout);

   232   },

   233 

   234   wrap: function(wrapper) {

   235     var __method = this;

   236     return function() {

   237       return wrapper.apply(this, [__method.bind(this)].concat($A(arguments)));

   238     }

   239   },

   240 

   241   methodize: function() {

   242     if (this._methodized) return this._methodized;

   243     var __method = this;

   244     return this._methodized = function() {

   245       return __method.apply(null, [this].concat($A(arguments)));

   246     };

   247   }

   248 });

   249 

   250 Function.prototype.defer = Function.prototype.delay.curry(0.01);

   251 

   252 Date.prototype.toJSON = function() {

   253   return '"' + this.getUTCFullYear() + '-' +

   254     (this.getUTCMonth() + 1).toPaddedString(2) + '-' +

   255     this.getUTCDate().toPaddedString(2) + 'T' +

   256     this.getUTCHours().toPaddedString(2) + ':' +

   257     this.getUTCMinutes().toPaddedString(2) + ':' +

   258     this.getUTCSeconds().toPaddedString(2) + 'Z"';

   259 };

   260 

   261 var Try = {

   262   these: function() {

   263     var returnValue;

   264 

   265     for (var i = 0, length = arguments.length; i < length; i++) {

   266       var lambda = arguments[i];

   267       try {

   268         returnValue = lambda();

   269         break;

   270       } catch (e) { }

   271     }

   272 

   273     return returnValue;

   274   }

   275 };

   276 

   277 RegExp.prototype.match = RegExp.prototype.test;

   278 

   279 RegExp.escape = function(str) {

   280   return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');

   281 };

   282 

   283 /*--------------------------------------------------------------------------*/

   284 

   285 var PeriodicalExecuter = Class.create({

   286   initialize: function(callback, frequency) {

   287     this.callback = callback;

   288     this.frequency = frequency;

   289     this.currentlyExecuting = false;

   290 

   291     this.registerCallback();

   292   },

   293 

   294   registerCallback: function() {

   295     this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);

   296   },

   297 

   298   execute: function() {

   299     this.callback(this);

   300   },

   301 

   302   stop: function() {

   303     if (!this.timer) return;

   304     clearInterval(this.timer);

   305     this.timer = null;

   306   },

   307 

   308   onTimerEvent: function() {

   309     if (!this.currentlyExecuting) {

   310       try {

   311         this.currentlyExecuting = true;

   312         this.execute();

   313       } finally {

   314         this.currentlyExecuting = false;

   315       }

   316     }

   317   }

   318 });

   319 Object.extend(String, {

   320   interpret: function(value) {

   321     return value == null ? '' : String(value);

   322   },

   323   specialChar: {

   324     '\b': '\\b',

   325     '\t': '\\t',

   326     '\n': '\\n',

   327     '\f': '\\f',

   328     '\r': '\\r',

   329     '\\': '\\\\'

   330   }

   331 });

   332 

   333 Object.extend(String.prototype, {

   334   gsub: function(pattern, replacement) {

   335     var result = '', source = this, match;

   336     replacement = arguments.callee.prepareReplacement(replacement);

   337 

   338     while (source.length > 0) {

   339       if (match = source.match(pattern)) {

   340         result += source.slice(0, match.index);

   341         result += String.interpret(replacement(match));

   342         source  = source.slice(match.index + match[0].length);

   343       } else {

   344         result += source, source = '';

   345       }

   346     }

   347     return result;

   348   },

   349 

   350   sub: function(pattern, replacement, count) {

   351     replacement = this.gsub.prepareReplacement(replacement);

   352     count = Object.isUndefined(count) ? 1 : count;

   353 

   354     return this.gsub(pattern, function(match) {

   355       if (--count < 0) return match[0];

   356       return replacement(match);

   357     });

   358   },

   359 

   360   scan: function(pattern, iterator) {

   361     this.gsub(pattern, iterator);

   362     return String(this);

   363   },

   364 

   365   truncate: function(length, truncation) {

   366     length = length || 30;

   367     truncation = Object.isUndefined(truncation) ? '...' : truncation;

   368     return this.length > length ?

   369       this.slice(0, length - truncation.length) + truncation : String(this);

   370   },

   371 

   372   strip: function() {

   373     return this.replace(/^\s+/, '').replace(/\s+$/, '');

   374   },

   375 

   376   stripTags: function() {

   377     return this.replace(/<\/?[^>]+>/gi, '');

   378   },

   379 

   380   stripScripts: function() {

   381     return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');

   382   },

   383 

   384   extractScripts: function() {

   385     var matchAll = new RegExp(Prototype.ScriptFragment, 'img');

   386     var matchOne = new RegExp(Prototype.ScriptFragment, 'im');

   387     return (this.match(matchAll) || []).map(function(scriptTag) {

   388       return (scriptTag.match(matchOne) || ['', ''])[1];

   389     });

   390   },

   391 

   392   evalScripts: function() {

   393     return this.extractScripts().map(function(script) { return eval(script) });

   394   },

   395 

   396   escapeHTML: function() {

   397     var self = arguments.callee;

   398     self.text.data = this;

   399     return self.div.innerHTML;

   400   },

   401 

   402   unescapeHTML: function() {

   403     var div = new Element('div');

   404     div.innerHTML = this.stripTags();

   405     return div.childNodes[0] ? (div.childNodes.length > 1 ?

   406       $A(div.childNodes).inject('', function(memo, node) { return memo+node.nodeValue }) :

   407       div.childNodes[0].nodeValue) : '';

   408   },

   409 

   410   toQueryParams: function(separator) {

   411     var match = this.strip().match(/([^?#]*)(#.*)?$/);

   412     if (!match) return { };

   413 

   414     return match[1].split(separator || '&').inject({ }, function(hash, pair) {

   415       if ((pair = pair.split('='))[0]) {

   416         var key = decodeURIComponent(pair.shift());

   417         var value = pair.length > 1 ? pair.join('=') : pair[0];

   418         if (value != undefined) value = decodeURIComponent(value);

   419 

   420         if (key in hash) {

   421           if (!Object.isArray(hash[key])) hash[key] = [hash[key]];

   422           hash[key].push(value);

   423         }

   424         else hash[key] = value;

   425       }

   426       return hash;

   427     });

   428   },

   429 

   430   toArray: function() {

   431     return this.split('');

   432   },

   433 

   434   succ: function() {

   435     return this.slice(0, this.length - 1) +

   436       String.fromCharCode(this.charCodeAt(this.length - 1) + 1);

   437   },

   438 

   439   times: function(count) {

   440     return count < 1 ? '' : new Array(count + 1).join(this);

   441   },

   442 

   443   camelize: function() {

   444     var parts = this.split('-'), len = parts.length;

   445     if (len == 1) return parts[0];

   446 

   447     var camelized = this.charAt(0) == '-'

   448       ? parts[0].charAt(0).toUpperCase() + parts[0].substring(1)

   449       : parts[0];

   450 

   451     for (var i = 1; i < len; i++)

   452       camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);

   453 

   454     return camelized;

   455   },

   456 

   457   capitalize: function() {

   458     return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();

   459   },

   460 

   461   underscore: function() {

   462     return this.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'#{1}_#{2}').gsub(/([a-z\d])([A-Z])/,'#{1}_#{2}').gsub(/-/,'_').toLowerCase();

   463   },

   464 

   465   dasherize: function() {

   466     return this.gsub(/_/,'-');

   467   },

   468 

   469   inspect: function(useDoubleQuotes) {

   470     var escapedString = this.gsub(/[\x00-\x1f\\]/, function(match) {

   471       var character = String.specialChar[match[0]];

   472       return character ? character : '\\u00' + match[0].charCodeAt().toPaddedString(2, 16);

   473     });

   474     if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';

   475     return "'" + escapedString.replace(/'/g, '\\\'') + "'";

   476   },

   477 

   478   toJSON: function() {

   479     return this.inspect(true);

   480   },

   481 

   482   unfilterJSON: function(filter) {

   483     return this.sub(filter || Prototype.JSONFilter, '#{1}');

   484   },

   485 

   486   isJSON: function() {

   487     var str = this;

   488     if (str.blank()) return false;

   489     str = this.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');

   490     return (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(str);

   491   },

   492 

   493   evalJSON: function(sanitize) {

   494     var json = this.unfilterJSON();

   495     try {

   496       if (!sanitize || json.isJSON()) return eval('(' + json + ')');

   497     } catch (e) { }

   498     throw new SyntaxError('Badly formed JSON string: ' + this.inspect());

   499   },

   500 

   501   include: function(pattern) {

   502     return this.indexOf(pattern) > -1;

   503   },

   504 

   505   startsWith: function(pattern) {

   506     return this.indexOf(pattern) === 0;

   507   },

   508 

   509   endsWith: function(pattern) {

   510     var d = this.length - pattern.length;

   511     return d >= 0 && this.lastIndexOf(pattern) === d;

   512   },

   513 

   514   empty: function() {

   515     return this == '';

   516   },

   517 

   518   blank: function() {

   519     return /^\s*$/.test(this);

   520   },

   521 

   522   interpolate: function(object, pattern) {

   523     return new Template(this, pattern).evaluate(object);

   524   }

   525 });

   526 

   527 if (Prototype.Browser.WebKit || Prototype.Browser.IE) Object.extend(String.prototype, {

   528   escapeHTML: function() {

   529     return this.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');

   530   },

   531   unescapeHTML: function() {

   532     return this.replace(/&amp;/g,'&').replace(/&lt;/g,'<').replace(/&gt;/g,'>');

   533   }

   534 });

   535 

   536 String.prototype.gsub.prepareReplacement = function(replacement) {

   537   if (Object.isFunction(replacement)) return replacement;

   538   var template = new Template(replacement);

   539   return function(match) { return template.evaluate(match) };

   540 };

   541 

   542 String.prototype.parseQuery = String.prototype.toQueryParams;

   543 

   544 Object.extend(String.prototype.escapeHTML, {

   545   div:  document.createElement('div'),

   546   text: document.createTextNode('')

   547 });

   548 

   549 with (String.prototype.escapeHTML) div.appendChild(text);

   550 

   551 var Template = Class.create({

   552   initialize: function(template, pattern) {

   553     this.template = template.toString();

   554     this.pattern = pattern || Template.Pattern;

   555   },

   556 

   557   evaluate: function(object) {

   558     if (Object.isFunction(object.toTemplateReplacements))

   559       object = object.toTemplateReplacements();

   560 

   561     return this.template.gsub(this.pattern, function(match) {

   562       if (object == null) return '';

   563 

   564       var before = match[1] || '';

   565       if (before == '\\') return match[2];

   566 

   567       var ctx = object, expr = match[3];

   568       var pattern = /^([^.[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/;

   569       match = pattern.exec(expr);

   570       if (match == null) return before;

   571 

   572       while (match != null) {

   573         var comp = match[1].startsWith('[') ? match[2].gsub('\\\\]', ']') : match[1];

   574         ctx = ctx[comp];

   575         if (null == ctx || '' == match[3]) break;

   576         expr = expr.substring('[' == match[3] ? match[1].length : match[0].length);

   577         match = pattern.exec(expr);

   578       }

   579 

   580       return before + String.interpret(ctx);

   581     }.bind(this));

   582   }

   583 });

   584 Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;

   585 

   586 var $break = { };

   587 

   588 var Enumerable = {

   589   each: function(iterator, context) {

   590     var index = 0;

   591     iterator = iterator.bind(context);

   592     try {

   593       this._each(function(value) {

   594         iterator(value, index++);

   595       });

   596     } catch (e) {

   597       if (e != $break) throw e;

   598     }

   599     return this;

   600   },

   601 

   602   eachSlice: function(number, iterator, context) {

   603     iterator = iterator ? iterator.bind(context) : Prototype.K;

   604     var index = -number, slices = [], array = this.toArray();

   605     while ((index += number) < array.length)

   606       slices.push(array.slice(index, index+number));

   607     return slices.collect(iterator, context);

   608   },

   609 

   610   all: function(iterator, context) {

   611     iterator = iterator ? iterator.bind(context) : Prototype.K;

   612     var result = true;

   613     this.each(function(value, index) {

   614       result = result && !!iterator(value, index);

   615       if (!result) throw $break;

   616     });

   617     return result;

   618   },

   619 

   620   any: function(iterator, context) {

   621     iterator = iterator ? iterator.bind(context) : Prototype.K;

   622     var result = false;

   623     this.each(function(value, index) {

   624       if (result = !!iterator(value, index))

   625         throw $break;

   626     });

   627     return result;

   628   },

   629 

   630   collect: function(iterator, context) {

   631     iterator = iterator ? iterator.bind(context) : Prototype.K;

   632     var results = [];

   633     this.each(function(value, index) {

   634       results.push(iterator(value, index));

   635     });

   636     return results;

   637   },

   638 

   639   detect: function(iterator, context) {

   640     iterator = iterator.bind(context);

   641     var result;

   642     this.each(function(value, index) {

   643       if (iterator(value, index)) {

   644         result = value;

   645         throw $break;

   646       }

   647     });

   648     return result;

   649   },

   650 

   651   findAll: function(iterator, context) {

   652     iterator = iterator.bind(context);

   653     var results = [];

   654     this.each(function(value, index) {

   655       if (iterator(value, index))

   656         results.push(value);

   657     });

   658     return results;

   659   },

   660 

   661   grep: function(filter, iterator, context) {

   662     iterator = iterator ? iterator.bind(context) : Prototype.K;

   663     var results = [];

   664 

   665     if (Object.isString(filter))

   666       filter = new RegExp(filter);

   667 

   668     this.each(function(value, index) {

   669       if (filter.match(value))

   670         results.push(iterator(value, index));

   671     });

   672     return results;

   673   },

   674 

   675   include: function(object) {

   676     if (Object.isFunction(this.indexOf))

   677       if (this.indexOf(object) != -1) return true;

   678 

   679     var found = false;

   680     this.each(function(value) {

   681       if (value == object) {

   682         found = true;

   683         throw $break;

   684       }

   685     });

   686     return found;

   687   },

   688 

   689   inGroupsOf: function(number, fillWith) {

   690     fillWith = Object.isUndefined(fillWith) ? null : fillWith;

   691     return this.eachSlice(number, function(slice) {

   692       while(slice.length < number) slice.push(fillWith);

   693       return slice;

   694     });

   695   },

   696 

   697   inject: function(memo, iterator, context) {

   698     iterator = iterator.bind(context);

   699     this.each(function(value, index) {

   700       memo = iterator(memo, value, index);

   701     });

   702     return memo;

   703   },

   704 

   705   invoke: function(method) {

   706     var args = $A(arguments).slice(1);

   707     return this.map(function(value) {

   708       return value[method].apply(value, args);

   709     });

   710   },

   711 

   712   max: function(iterator, context) {

   713     iterator = iterator ? iterator.bind(context) : Prototype.K;

   714     var result;

   715     this.each(function(value, index) {

   716       value = iterator(value, index);

   717       if (result == null || value >= result)

   718         result = value;

   719     });

   720     return result;

   721   },

   722 

   723   min: function(iterator, context) {

   724     iterator = iterator ? iterator.bind(context) : Prototype.K;

   725     var result;

   726     this.each(function(value, index) {

   727       value = iterator(value, index);

   728       if (result == null || value < result)

   729         result = value;

   730     });

   731     return result;

   732   },

   733 

   734   partition: function(iterator, context) {

   735     iterator = iterator ? iterator.bind(context) : Prototype.K;

   736     var trues = [], falses = [];

   737     this.each(function(value, index) {

   738       (iterator(value, index) ?

   739         trues : falses).push(value);

   740     });

   741     return [trues, falses];

   742   },

   743 

   744   pluck: function(property) {

   745     var results = [];

   746     this.each(function(value) {

   747       results.push(value[property]);

   748     });

   749     return results;

   750   },

   751 

   752   reject: function(iterator, context) {

   753     iterator = iterator.bind(context);

   754     var results = [];

   755     this.each(function(value, index) {

   756       if (!iterator(value, index))

   757         results.push(value);

   758     });

   759     return results;

   760   },

   761 

   762   sortBy: function(iterator, context) {

   763     iterator = iterator.bind(context);

   764     return this.map(function(value, index) {

   765       return {value: value, criteria: iterator(value, index)};

   766     }).sort(function(left, right) {

   767       var a = left.criteria, b = right.criteria;

   768       return a < b ? -1 : a > b ? 1 : 0;

   769     }).pluck('value');

   770   },

   771 

   772   toArray: function() {

   773     return this.map();

   774   },

   775 

   776   zip: function() {

   777     var iterator = Prototype.K, args = $A(arguments);

   778     if (Object.isFunction(args.last()))

   779       iterator = args.pop();

   780 

   781     var collections = [this].concat(args).map($A);

   782     return this.map(function(value, index) {

   783       return iterator(collections.pluck(index));

   784     });

   785   },

   786 

   787   size: function() {

   788     return this.toArray().length;

   789   },

   790 

   791   inspect: function() {

   792     return '#<Enumerable:' + this.toArray().inspect() + '>';

   793   }

   794 };

   795 

   796 Object.extend(Enumerable, {

   797   map:     Enumerable.collect,

   798   find:    Enumerable.detect,

   799   select:  Enumerable.findAll,

   800   filter:  Enumerable.findAll,

   801   member:  Enumerable.include,

   802   entries: Enumerable.toArray,

   803   every:   Enumerable.all,

   804   some:    Enumerable.any

   805 });

   806 function $A(iterable) {

   807   if (!iterable) return [];

   808   if (iterable.toArray) return iterable.toArray();

   809   var length = iterable.length || 0, results = new Array(length);

   810   while (length--) results[length] = iterable[length];

   811   return results;

   812 }

   813 

   814 if (Prototype.Browser.WebKit) {

   815   function $A(iterable) {

   816     if (!iterable) return [];

   817     if (!(Object.isFunction(iterable) && iterable == '[object NodeList]') &&

   818         iterable.toArray) return iterable.toArray();

   819     var length = iterable.length || 0, results = new Array(length);

   820     while (length--) results[length] = iterable[length];

   821     return results;

   822   }

   823 }

   824 

   825 Array.from = $A;

   826 

   827 Object.extend(Array.prototype, Enumerable);

   828 

   829 if (!Array.prototype._reverse) Array.prototype._reverse = Array.prototype.reverse;

   830 

   831 Object.extend(Array.prototype, {

   832   _each: function(iterator) {

   833     for (var i = 0, length = this.length; i < length; i++)

   834       iterator(this[i]);

   835   },

   836 

   837   clear: function() {

   838     this.length = 0;

   839     return this;

   840   },

   841 

   842   first: function() {

   843     return this[0];

   844   },

   845 

   846   last: function() {

   847     return this[this.length - 1];

   848   },

   849 

   850   compact: function() {

   851     return this.select(function(value) {

   852       return value != null;

   853     });

   854   },

   855 

   856   flatten: function() {

   857     return this.inject([], function(array, value) {

   858       return array.concat(Object.isArray(value) ?

   859         value.flatten() : [value]);

   860     });

   861   },

   862 

   863   without: function() {

   864     var values = $A(arguments);

   865     return this.select(function(value) {

   866       return !values.include(value);

   867     });

   868   },

   869 

   870   reverse: function(inline) {

   871     return (inline !== false ? this : this.toArray())._reverse();

   872   },

   873 

   874   reduce: function() {

   875     return this.length > 1 ? this : this[0];

   876   },

   877 

   878   uniq: function(sorted) {

   879     return this.inject([], function(array, value, index) {

   880       if (0 == index || (sorted ? array.last() != value : !array.include(value)))

   881         array.push(value);

   882       return array;

   883     });

   884   },

   885 

   886   intersect: function(array) {

   887     return this.uniq().findAll(function(item) {

   888       return array.detect(function(value) { return item === value });

   889     });

   890   },

   891 

   892   clone: function() {

   893     return [].concat(this);

   894   },

   895 

   896   size: function() {

   897     return this.length;

   898   },

   899 

   900   inspect: function() {

   901     return '[' + this.map(Object.inspect).join(', ') + ']';

   902   },

   903 

   904   toJSON: function() {

   905     var results = [];

   906     this.each(function(object) {

   907       var value = Object.toJSON(object);

   908       if (!Object.isUndefined(value)) results.push(value);

   909     });

   910     return '[' + results.join(', ') + ']';

   911   }

   912 });

   913 

   914 // use native browser JS 1.6 implementation if available

   915 if (Object.isFunction(Array.prototype.forEach))

   916   Array.prototype._each = Array.prototype.forEach;

   917 

   918 if (!Array.prototype.indexOf) Array.prototype.indexOf = function(item, i) {

   919   i || (i = 0);

   920   var length = this.length;

   921   if (i < 0) i = length + i;

   922   for (; i < length; i++)

   923     if (this[i] === item) return i;

   924   return -1;

   925 };

   926 

   927 if (!Array.prototype.lastIndexOf) Array.prototype.lastIndexOf = function(item, i) {

   928   i = isNaN(i) ? this.length : (i < 0 ? this.length + i : i) + 1;

   929   var n = this.slice(0, i).reverse().indexOf(item);

   930   return (n < 0) ? n : i - n - 1;

   931 };

   932 

   933 Array.prototype.toArray = Array.prototype.clone;

   934 

   935 function $w(string) {

   936   if (!Object.isString(string)) return [];

   937   string = string.strip();

   938   return string ? string.split(/\s+/) : [];

   939 }

   940 

   941 if (Prototype.Browser.Opera){

   942   Array.prototype.concat = function() {

   943     var array = [];

   944     for (var i = 0, length = this.length; i < length; i++) array.push(this[i]);

   945     for (var i = 0, length = arguments.length; i < length; i++) {

   946       if (Object.isArray(arguments[i])) {

   947         for (var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)

   948           array.push(arguments[i][j]);

   949       } else {

   950         array.push(arguments[i]);

   951       }

   952     }

   953     return array;

   954   };

   955 }

   956 Object.extend(Number.prototype, {

   957   toColorPart: function() {

   958     return this.toPaddedString(2, 16);

   959   },

   960 

   961   succ: function() {

   962     return this + 1;

   963   },

   964 

   965   times: function(iterator) {

   966     $R(0, this, true).each(iterator);

   967     return this;

   968   },

   969 

   970   toPaddedString: function(length, radix) {

   971     var string = this.toString(radix || 10);

   972     return '0'.times(length - string.length) + string;

   973   },

   974 

   975   toJSON: function() {

   976     return isFinite(this) ? this.toString() : 'null';

   977   }

   978 });

   979 

   980 $w('abs round ceil floor').each(function(method){

   981   Number.prototype[method] = Math[method].methodize();

   982 });

   983 function $H(object) {

   984   return new Hash(object);

   985 };

   986 

   987 var Hash = Class.create(Enumerable, (function() {

   988 

   989   function toQueryPair(key, value) {

   990     if (Object.isUndefined(value)) return key;

   991     return key + '=' + encodeURIComponent(String.interpret(value));

   992   }

   993 

   994   return {

   995     initialize: function(object) {

   996       this._object = Object.isHash(object) ? object.toObject() : Object.clone(object);

   997     },

   998 

   999     _each: function(iterator) {

  1000       for (var key in this._object) {

  1001         var value = this._object[key], pair = [key, value];

  1002         pair.key = key;

  1003         pair.value = value;

  1004         iterator(pair);

  1005       }

  1006     },

  1007 

  1008     set: function(key, value) {

  1009       return this._object[key] = value;

  1010     },

  1011 

  1012     get: function(key) {

  1013       return this._object[key];

  1014     },

  1015 

  1016     unset: function(key) {

  1017       var value = this._object[key];

  1018       delete this._object[key];

  1019       return value;

  1020     },

  1021 

  1022     toObject: function() {

  1023       return Object.clone(this._object);

  1024     },

  1025 

  1026     keys: function() {

  1027       return this.pluck('key');

  1028     },

  1029 

  1030     values: function() {

  1031       return this.pluck('value');

  1032     },

  1033 

  1034     index: function(value) {

  1035       var match = this.detect(function(pair) {

  1036         return pair.value === value;

  1037       });

  1038       return match && match.key;

  1039     },

  1040 

  1041     merge: function(object) {

  1042       return this.clone().update(object);

  1043     },

  1044 

  1045     update: function(object) {

  1046       return new Hash(object).inject(this, function(result, pair) {

  1047         result.set(pair.key, pair.value);

  1048         return result;

  1049       });

  1050     },

  1051 

  1052     toQueryString: function() {

  1053       return this.map(function(pair) {

  1054         var key = encodeURIComponent(pair.key), values = pair.value;

  1055 

  1056         if (values && typeof values == 'object') {

  1057           if (Object.isArray(values))

  1058             return values.map(toQueryPair.curry(key)).join('&');

  1059         }

  1060         return toQueryPair(key, values);

  1061       }).join('&');

  1062     },

  1063 

  1064     inspect: function() {

  1065       return '#<Hash:{' + this.map(function(pair) {

  1066         return pair.map(Object.inspect).join(': ');

  1067       }).join(', ') + '}>';

  1068     },

  1069 

  1070     toJSON: function() {

  1071       return Object.toJSON(this.toObject());

  1072     },

  1073 

  1074     clone: function() {

  1075       return new Hash(this);

  1076     }

  1077   }

  1078 })());

  1079 

  1080 Hash.prototype.toTemplateReplacements = Hash.prototype.toObject;

  1081 Hash.from = $H;

  1082 var ObjectRange = Class.create(Enumerable, {

  1083   initialize: function(start, end, exclusive) {

  1084     this.start = start;

  1085     this.end = end;

  1086     this.exclusive = exclusive;

  1087   },

  1088 

  1089   _each: function(iterator) {

  1090     var value = this.start;

  1091     while (this.include(value)) {

  1092       iterator(value);

  1093       value = value.succ();

  1094     }

  1095   },

  1096 

  1097   include: function(value) {

  1098     if (value < this.start)

  1099       return false;

  1100     if (this.exclusive)

  1101       return value < this.end;

  1102     return value <= this.end;

  1103   }

  1104 });

  1105 

  1106 var $R = function(start, end, exclusive) {

  1107   return new ObjectRange(start, end, exclusive);

  1108 };

  1109 

  1110 var Ajax = {

  1111   getTransport: function() {

  1112     return Try.these(

  1113       function() {return new XMLHttpRequest()},

  1114       function() {return new ActiveXObject('Msxml2.XMLHTTP')},

  1115       function() {return new ActiveXObject('Microsoft.XMLHTTP')}

  1116     ) || false;

  1117   },

  1118 

  1119   activeRequestCount: 0

  1120 };

  1121 

  1122 Ajax.Responders = {

  1123   responders: [],

  1124 

  1125   _each: function(iterator) {

  1126     this.responders._each(iterator);

  1127   },

  1128 

  1129   register: function(responder) {

  1130     if (!this.include(responder))

  1131       this.responders.push(responder);

  1132   },

  1133 

  1134   unregister: function(responder) {

  1135     this.responders = this.responders.without(responder);

  1136   },