//additional js from prototype.js

var Class = {
    create: function() {
        return function() {
            this.initialize.apply(this, arguments);
        }
    }
}

var Hash = {
    _each: function(iterator) {
        for (key in this) {
            var value = this[key];
            if (typeof value == 'function') continue;

            var pair = [key, value];
            pair.key = key;
            pair.value = value;
            iterator(pair);
        }
    },

    keys: function() {
    return this.pluck('key');
    },

    values: function() {
    return this.pluck('value');
    },

    merge: function(hash) {
        return $H(hash).inject($H(this), function(mergedHash, pair) {
            mergedHash[pair.key] = pair.value;
            return mergedHash;
        });
    },

    toQueryString: function() {
    return this.map(function(pair) {
        return pair.map(encodeURIComponent).join('=');
    }).join('&');
    },

    inspect: function() {
    return '#<Hash:{' + this.map(function(pair) {
        return pair.map(Object.inspect).join(': ');
    }).join(', ') + '}>';
    }
}

function $H(object) {
    var hash = Object.extend({}, object || {});
    Object.extend(hash, Enumerable);
    Object.extend(hash, Hash);
    return hash;
}

Object.extend = function(destination, source) {
    for (property in source) {
        destination[property] = source[property];
    }
    return destination;
}

var Enumerable = {
        each: function(iterator) {
        var index = 0;
        try {
            this._each(function(value) {
                try {
                    iterator(value, index++);
                } catch (e) {
                    if (e != $continue) throw e;
                }
            });
        } catch (e) {
            if (e != $break) throw e;
        }
    },

    all: function(iterator) {
        var result = true;
        this.each(function(value, index) {
            result = result && !!(iterator || Prototype.K)(value, index);
            if (!result) throw $break;
        });
        return result;
    },

    any: function(iterator) {
    var result = true;
        this.each(function(value, index) {
            if (result = !!(iterator || Prototype.K)(value, index))
            throw $break;
        });
        return result;
    },

    collect: function(iterator) {
        var results = [];
        this.each(function(value, index) {
            results.push(iterator(value, index));
        });
        return results;
    },

    detect: function (iterator) {
        var result;
        this.each(function(value, index) {
            if (iterator(value, index)) {
                result = value;
                throw $break;
            }
        });
        return result;
    },

    findAll: function(iterator) {
        var results = [];
        this.each(function(value, index) {
            if (iterator(value, index))
            results.push(value);
        });
        return results;
    },

    grep: function(pattern, iterator) {
        var results = [];
        this.each(function(value, index) {
            var stringValue = value.toString();
            if (stringValue.match(pattern))
            results.push((iterator || Prototype.K)(value, index));
        })
        return results;
    },

    include: function(object) {
        var found = false;
        this.each(function(value) {
            if (value == object) {
                found = true;
                throw $break;
            }
        });
        return found;
    },

    inject: function(memo, iterator) {
        this.each(function(value, index) {
            memo = iterator(memo, value, index);
        });
        return memo;
    },

    invoke: function(method) {
        var args = $A(arguments).slice(1);
        return this.collect(function(value) {
            return value[method].apply(value, args);
        });
    },

    max: function(iterator) {
        var result;
        this.each(function(value, index) {
            value = (iterator || Prototype.K)(value, index);
            if (value >= (result || value))
            result = value;
        });
        return result;
    },

    min: function(iterator) {
        var result;
        this.each(function(value, index) {
            value = (iterator || Prototype.K)(value, index);
            if (value <= (result || value))
            result = value;
        });
        return result;
    },

    partition: function(iterator) {
        var trues = [], falses = [];
        this.each(function(value, index) {
            ((iterator || Prototype.K)(value, index) ?
            trues : falses).push(value);
        });
        return [trues, falses];
    },

    pluck: function(property) {
        var results = [];
        this.each(function(value, index) {
            results.push(value[property]);
        });
        return results;
    },

    reject: function(iterator) {
        var results = [];
        this.each(function(value, index) {
            if (!iterator(value, index))
            results.push(value);
        });
        return results;
    },

    sortBy: function(iterator) {
        return this.collect(function(value, index) {
            return {value: value, criteria: iterator(value, index)};
        }).sort(function(left, right) {
            var a = left.criteria, b = right.criteria;
            return a < b ? -1 : a > b ? 1 : 0;
        }).pluck('value');
    },

    toArray: function() {
        return this.collect(Prototype.K);
    },

    zip: function() {
        var iterator = Prototype.K, args = $A(arguments);
        if (typeof args.last() == 'function')
        iterator = args.pop();

        var collections = [this].concat(args).map($A);
        return this.map(function(value, index) {
            iterator(value = collections.pluck(index));
            return value;
        });
    },

    inspect: function() {
        return '#<Enumerable:' + this.toArray().inspect() + '>';
    }
}
//end additional js from prototype.js