/*!

 * byophpjs.org
 * v1

 */

var Phpjsorg = new Class({

	
	
////////////////////////////////////////////////////////////////////////////////////////////////////////////////	
//  PHPJS.ORG FUNCTIONS -------------------------   http://phpjs.org ------------------- 	
	
	// ***********************************************************************
	// implode ///////////////////////////////////////////////////////////////
	 implode : function (glue, pieces) {
	    // Joins array elements placing glue string between items and return one string  
	    // 
	    // version: 1103.1210
	    // discuss at: http://phpjs.org/functions/implode    // +   original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // +   improved by: Waldo Malqui Silva
	    // +   improved by: Itsacon (http://www.itsacon.net/)
	    // +   bugfixed by: Brett Zamir (http://brett-zamir.me)
	    // *     example 1: implode(' ', ['Kevin', 'van', 'Zonneveld']);    // *     returns 1: 'Kevin van Zonneveld'
	    // *     example 2: implode(' ', {first:'Kevin', last: 'van Zonneveld'});
	    // *     returns 2: 'Kevin van Zonneveld'
	    var i = '',
	        retVal = '',        tGlue = '';
	    if (arguments.length === 1) {
	        pieces = glue;
	        glue = '';
	    }    if (typeof(pieces) === 'object') {
	        if (pieces instanceof Array) {
	            return pieces.join(glue);
	        } else {
	            for (i in pieces) {                retVal += tGlue + pieces[i];
	                tGlue = glue;
	            }
	            return retVal;
	        }    } else {
	        return pieces;
	    }
	},
	
	// /implode ///
	
	// ***********************************************************************
	// unserialize ///////////////////////////////////////////////////////////
	unserialize : function (data) {
	    // http://kevin.vanzonneveld.net
	    // +     original by: Arpad Ray (mailto:arpad@php.net)
	    // +     improved by: Pedro Tainha (http://www.pedrotainha.com)
	    // +     bugfixed by: dptr1988
	    // +      revised by: d3x
	    // +     improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // +        input by: Brett Zamir (http://brett-zamir.me)
	    // +     improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // +     improved by: Chris
	    // +     improved by: James
	    // +        input by: Martin (http://www.erlenwiese.de/)
	    // +     bugfixed by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // +     improved by: Le Torbi
	    // +     input by: kilops
	    // +     bugfixed by: Brett Zamir (http://brett-zamir.me)
	    // -      depends on: utf8_decode
	    // %            note: We feel the main purpose of this function should be to ease the transport of data between php & js
	    // %            note: Aiming for PHP-compatibility, we have to translate objects to arrays
	    // *       example 1: unserialize('a:3:{i:0;s:5:"Kevin";i:1;s:3:"van";i:2;s:9:"Zonneveld";}');
	    // *       returns 1: ['Kevin', 'van', 'Zonneveld']
	    // *       example 2: unserialize('a:3:{s:9:"firstName";s:5:"Kevin";s:7:"midName";s:3:"van";s:7:"surName";s:9:"Zonneveld";}');
	    // *       returns 2: {firstName: 'Kevin', midName: 'van', surName: 'Zonneveld'}
	    var that = this;
	    var utf8Overhead = function (chr) {
	        // http://phpjs.org/functions/unserialize:571#comment_95906
	        var code = chr.charCodeAt(0);
	        if (code < 0x0080) {
	            return 0;
	        }
	        if (code < 0x0800) {
	            return 1;
	        }
	        return 2;
	    };


	    var error = function (type, msg, filename, line) {
	        throw new that.window[type](msg, filename, line);
	    };
	    var read_until = function (data, offset, stopchr) {
	        var buf = [];
	        var chr = data.slice(offset, offset + 1);
	        var i = 2;
	        while (chr != stopchr) {
	            if ((i + offset) > data.length) {
	                error('Error', 'Invalid');
	            }
	            buf.push(chr);
	            chr = data.slice(offset + (i - 1), offset + i);
	            i += 1;
	        }
	        return [buf.length, buf.join('')];
	    };
	    var read_chrs = function (data, offset, length) {
	        var buf;

	        buf = [];
	        for (var i = 0; i < length; i++) {
	            var chr = data.slice(offset + (i - 1), offset + i);
	            buf.push(chr);
	            length -= utf8Overhead(chr);
	        }
	        return [buf.length, buf.join('')];
	    };
	    var _unserialize = function (data, offset) {
	        var readdata;
	        var readData;
	        var chrs = 0;
	        var ccount;
	        var stringlength;
	        var keyandchrs;
	        var keys;

	        if (!offset) {
	            offset = 0;
	        }
	        var dtype = (data.slice(offset, offset + 1)).toLowerCase();

	        var dataoffset = offset + 2;
	        var typeconvert = function (x) {
	            return x;
	        };

	        switch (dtype) {
	        case 'i':
	            typeconvert = function (x) {
	                return parseInt(x, 10);
	            };
	            readData = read_until(data, dataoffset, ';');
	            chrs = readData[0];
	            readdata = readData[1];
	            dataoffset += chrs + 1;
	            break;
	        case 'b':
	            typeconvert = function (x) {
	                return parseInt(x, 10) !== 0;
	            };
	            readData = read_until(data, dataoffset, ';');
	            chrs = readData[0];
	            readdata = readData[1];
	            dataoffset += chrs + 1;
	            break;
	        case 'd':
	            typeconvert = function (x) {
	                return parseFloat(x);
	            };
	            readData = read_until(data, dataoffset, ';');
	            chrs = readData[0];
	            readdata = readData[1];
	            dataoffset += chrs + 1;
	            break;
	        case 'n':
	            readdata = null;
	            break;
	        case 's':
	            ccount = read_until(data, dataoffset, ':');
	            chrs = ccount[0];
	            stringlength = ccount[1];
	            dataoffset += chrs + 2;

	            readData = read_chrs(data, dataoffset + 1, parseInt(stringlength, 10));
	            chrs = readData[0];
	            readdata = readData[1];
	            dataoffset += chrs + 2;
	            if (chrs != parseInt(stringlength, 10) && chrs != readdata.length) {
	                error('SyntaxError', 'String length mismatch');
	            }

	            // Length was calculated on an utf-8 encoded string
	            // so wait with decoding
	            readdata = that.utf8_decode(readdata);
	            break;
	        case 'a':
	            readdata = {};

	            keyandchrs = read_until(data, dataoffset, ':');
	            chrs = keyandchrs[0];
	            keys = keyandchrs[1];
	            dataoffset += chrs + 2;

	            for (var i = 0; i < parseInt(keys, 10); i++) {
	                var kprops = _unserialize(data, dataoffset);
	                var kchrs = kprops[1];
	                var key = kprops[2];
	                dataoffset += kchrs;

	                var vprops = _unserialize(data, dataoffset);
	                var vchrs = vprops[1];
	                var value = vprops[2];
	                dataoffset += vchrs;

	                readdata[key] = value;
	            }

	            dataoffset += 1;
	            break;
	        default:
	            error('SyntaxError', 'Unknown / Unhandled data type(s): ' + dtype);
	            break;
	        }
	        return [dtype, dataoffset - offset, typeconvert(readdata)];
	    };

	    return _unserialize((data + ''), 0)[2];
	},
   // / unserialize //////////////////////////////////////
	
	// ***********************************************************************
	// utf8_decode ///////////////////////////////////////////////////////////	
	utf8_decode : function (str_data) {
	    // http://kevin.vanzonneveld.net
	    // +   original by: Webtoolkit.info (http://www.webtoolkit.info/)
	    // +      input by: Aman Gupta
	    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // +   improved by: Norman "zEh" Fuchs
	    // +   bugfixed by: hitwork
	    // +   bugfixed by: Onno Marsman
	    // +      input by: Brett Zamir (http://brett-zamir.me)
	    // +   bugfixed by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // *     example 1: utf8_decode('Kevin van Zonneveld');
	    // *     returns 1: 'Kevin van Zonneveld'
	    var tmp_arr = [],
	        i = 0,
	        ac = 0,
	        c1 = 0,
	        c2 = 0,
	        c3 = 0;

	    str_data += '';

	    while (i < str_data.length) {
	        c1 = str_data.charCodeAt(i);
	        if (c1 < 128) {
	            tmp_arr[ac++] = String.fromCharCode(c1);
	            i++;
	        } else if (c1 > 191 && c1 < 224) {
	            c2 = str_data.charCodeAt(i + 1);
	            tmp_arr[ac++] = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));
	            i += 2;
	        } else {
	            c2 = str_data.charCodeAt(i + 1);
	            c3 = str_data.charCodeAt(i + 2);
	            tmp_arr[ac++] = String.fromCharCode(((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
	            i += 3;
	        }
	    }

	    return tmp_arr.join('');
	},
	// /utf8_decode//
	
	// ***********************************************************************
	// count ///////////////////////////////////////////////////////////
	count : function (mixed_var, mode) {
	    // http://kevin.vanzonneveld.net
	    // +   original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // +      input by: Waldo Malqui Silva
	    // +   bugfixed by: Soren Hansen
	    // +      input by: merabi
	    // +   improved by: Brett Zamir (http://brett-zamir.me)
	    // +   bugfixed by: Olivier Louvignes (http://mg-crea.com/)
	    // *     example 1: count([[0,0],[0,-4]], 'COUNT_RECURSIVE');
	    // *     returns 1: 6
	    // *     example 2: count({'one' : [1,2,3,4,5]}, 'COUNT_RECURSIVE');
	    // *     returns 2: 6
	    var key, cnt = 0;

	    if (mixed_var === null || typeof mixed_var === 'undefined') {
	        return 0;
	    } else if (mixed_var.constructor !== Array && mixed_var.constructor !== Object) {
	        return 1;
	    }

	    if (mode === 'COUNT_RECURSIVE') {
	        mode = 1;
	    }
	    if (mode != 1) {
	        mode = 0;
	    }

	    for (key in mixed_var) {
	        if (mixed_var.hasOwnProperty(key)) {
	            cnt++;
	            if (mode == 1 && mixed_var[key] && (mixed_var[key].constructor === Array || mixed_var[key].constructor === Object)) {
	                cnt += this.count(mixed_var[key], 1);
	            }
	        }
	    }

	    return cnt;
	},
	// count//
	
	// ***********************************************************************
	// explode ///////////////////////////////////////////////////////////	
	 explode : function (delimiter, string, limit) {
	    // http://kevin.vanzonneveld.net
	    // +     original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // +     improved by: kenneth
	    // +     improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // +     improved by: d3x
	    // +     bugfixed by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // *     example 1: explode(' ', 'Kevin van Zonneveld');
	    // *     returns 1: {0: 'Kevin', 1: 'van', 2: 'Zonneveld'}
	    // *     example 2: explode('=', 'a=bc=d', 2);
	    // *     returns 2: ['a', 'bc=d']
	    var emptyArray = {
	        0: ''
	    };

	    // third argument is not required
	    if (arguments.length < 2 || typeof arguments[0] == 'undefined' || typeof arguments[1] == 'undefined') {
	        return null;
	    }

	    if (delimiter === '' || delimiter === false || delimiter === null) {
	        return false;
	    }

	    if (typeof delimiter == 'function' || typeof delimiter == 'object' || typeof string == 'function' || typeof string == 'object') {
	        return emptyArray;
	    }

	    if (delimiter === true) {
	        delimiter = '1';
	    }

	    if (!limit) {
	        return string.toString().split(delimiter.toString());
	    } else {
	        // support for limit argument
	        var splitted = string.toString().split(delimiter.toString());
	        var partA = splitted.splice(0, limit - 1);
	        var partB = splitted.join(delimiter.toString());
	        partA.push(partB);
	        return partA;
	    }
	},
	// /explode///
	
	// ***********************************************************************
	// serialize ///////////////////////////////////////////////////////////	
	 serialize : function (mixed_value) {
	    // http://kevin.vanzonneveld.net
	    // +   original by: Arpad Ray (mailto:arpad@php.net)
	    // +   improved by: Dino
	    // +   bugfixed by: Andrej Pavlovic
	    // +   bugfixed by: Garagoth
	    // +      input by: DtTvB (http://dt.in.th/2008-09-16.string-length-in-bytes.html)
	    // +   bugfixed by: Russell Walker (http://www.nbill.co.uk/)
	    // +   bugfixed by: Jamie Beck (http://www.terabit.ca/)
	    // +      input by: Martin (http://www.erlenwiese.de/)
	    // +   bugfixed by: Kevin van Zonneveld (http://kevin.vanzonneveld.net/)
	    // +   improved by: Le Torbi (http://www.letorbi.de/)
	    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net/)
	    // +   bugfixed by: Ben (http://benblume.co.uk/)
	    // -    depends on: utf8_encode
	    // %          note: We feel the main purpose of this function should be to ease the transport of data between php & js
	    // %          note: Aiming for PHP-compatibility, we have to translate objects to arrays
	    // *     example 1: serialize(['Kevin', 'van', 'Zonneveld']);
	    // *     returns 1: 'a:3:{i:0;s:5:"Kevin";i:1;s:3:"van";i:2;s:9:"Zonneveld";}'
	    // *     example 2: serialize({firstName: 'Kevin', midName: 'van', surName: 'Zonneveld'});
	    // *     returns 2: 'a:3:{s:9:"firstName";s:5:"Kevin";s:7:"midName";s:3:"van";s:7:"surName";s:9:"Zonneveld";}'
	    var _utf8Size = function (str) {
	        var size = 0,
	            i = 0,
	            l = str.length,
	            code = '';
	        for (i = 0; i < l; i++) {
	            code = str.charCodeAt(i);
	            if (code < 0x0080) {
	                size += 1;
	            } else if (code < 0x0800) {
	                size += 2;
	            } else {
	                size += 3;
	            }
	        }
	        return size;
	    };
	    var _getType = function (inp) {
	        var type = typeof inp,
	            match;
	        var key;

	        if (type === 'object' && !inp) {
	            return 'null';
	        }
	        if (type === "object") {
	            if (!inp.constructor) {
	                return 'object';
	            }
	            var cons = inp.constructor.toString();
	            match = cons.match(/(\w+)\(/);
	            if (match) {
	                cons = match[1].toLowerCase();
	            }
	            var types = ["boolean", "number", "string", "array"];
	            for (key in types) {
	                if (cons == types[key]) {
	                    type = types[key];
	                    break;
	                }
	            }
	        }
	        return type;
	    };
	    var type = _getType(mixed_value);
	    var val, ktype = '';

	    switch (type) {
	    case "function":
	        val = "";
	        break;
	    case "boolean":
	        val = "b:" + (mixed_value ? "1" : "0");
	        break;
	    case "number":
	        val = (Math.round(mixed_value) == mixed_value ? "i" : "d") + ":" + mixed_value;
	        break;
	    case "string":
	        val = "s:" + _utf8Size(mixed_value) + ":\"" + mixed_value + "\"";
	        break;
	    case "array":
	    case "object":
	        val = "a";
	/*
	            if (type == "object") {
	                var objname = mixed_value.constructor.toString().match(/(\w+)\(\)/);
	                if (objname == undefined) {
	                    return;
	                }
	                objname[1] = this.serialize(objname[1]);
	                val = "O" + objname[1].substring(1, objname[1].length - 1);
	            }
	            */
	        var count = 0;
	        var vals = "";
	        var okey;
	        var key;
	        for (key in mixed_value) {
	            if (mixed_value.hasOwnProperty(key)) {
	                ktype = _getType(mixed_value[key]);
	                if (ktype === "function") {
	                    continue;
	                }

	                okey = (key.match(/^[0-9]+$/) ? parseInt(key, 10) : key);
	                vals += this.serialize(okey) + this.serialize(mixed_value[key]);
	                count++;
	            }
	        }
	        val += ":" + count + ":{" + vals + "}";
	        break;
	    case "undefined":
	        // Fall-through
	    default:
	        // if the JS object has a property which contains a null value, the string cannot be unserialized by PHP
	        val = "N";
	        break;
	    }
	    if (type !== "object" && type !== "array") {
	        val += ";";
	    }
	    return val;
	},
	
	// /serialize//
	
	// **********************************************************
	// date ////////////////////////////////////////////////////
	date : function (format, timestamp) {
	    
	    var that = this,
	        jsdate, f, formatChr = /\\?([a-z])/gi,
	        formatChrCb,
	        // Keep this here (works, but for code commented-out
	        // below for file size reasons)
	        //, tal= [],
	        _pad = function (n, c) {
	            if ((n = n + '').length < c) {
	                return new Array((++c) - n.length).join('0') + n;
	            }
	            return n;
	        },
	        txt_words = ["Sun", "Mon", "Tues", "Wednes", "Thurs", "Fri", "Satur", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
	    formatChrCb = function (t, s) {
	        return f[t] ? f[t]() : s;
	    };
	    f = {
	        // Day
	        d: function () { // Day of month w/leading 0; 01..31
	            return _pad(f.j(), 2);
	        },
	        D: function () { // Shorthand day name; Mon...Sun
	            return f.l().slice(0, 3);
	        },
	        j: function () { // Day of month; 1..31
	            return jsdate.getDate();
	        },
	        l: function () { // Full day name; Monday...Sunday
	            return txt_words[f.w()] + 'day';
	        },
	        N: function () { // ISO-8601 day of week; 1[Mon]..7[Sun]
	            return f.w() || 7;
	        },
	        S: function () { // Ordinal suffix for day of month; st, nd, rd, th
	            var j = f.j();
	            return j > 4 || j < 21 ? 'th' : {1: 'st', 2: 'nd', 3: 'rd'}[j % 10] || 'th';
	        },
	        w: function () { // Day of week; 0[Sun]..6[Sat]
	            return jsdate.getDay();
	        },
	        z: function () { // Day of year; 0..365
	            var a = new Date(f.Y(), f.n() - 1, f.j()),
	                b = new Date(f.Y(), 0, 1);
	            return Math.round((a - b) / 864e5) + 1;
	        },

	        // Week
	        W: function () { // ISO-8601 week number
	            var a = new Date(f.Y(), f.n() - 1, f.j() - f.N() + 3),
	                b = new Date(a.getFullYear(), 0, 4);
	            return _pad(1 + Math.round((a - b) / 864e5 / 7), 2);
	        },

	        // Month
	        F: function () { // Full month name; January...December
	            return txt_words[6 + f.n()];
	        },
	        m: function () { // Month w/leading 0; 01...12
	            return _pad(f.n(), 2);
	        },
	        M: function () { // Shorthand month name; Jan...Dec
	            return f.F().slice(0, 3);
	        },
	        n: function () { // Month; 1...12
	            return jsdate.getMonth() + 1;
	        },
	        t: function () { // Days in month; 28...31
	            return (new Date(f.Y(), f.n(), 0)).getDate();
	        },

	        // Year
	        L: function () { // Is leap year?; 0 or 1
	            return new Date(f.Y(), 1, 29).getMonth() === 1 | 0;
	        },
	        o: function () { // ISO-8601 year
	            var n = f.n(),
	                W = f.W(),
	                Y = f.Y();
	            return Y + (n === 12 && W < 9 ? -1 : n === 1 && W > 9);
	        },
	        Y: function () { // Full year; e.g. 1980...2010
	            return jsdate.getFullYear();
	        },
	        y: function () { // Last two digits of year; 00...99
	            return (f.Y() + "").slice(-2);
	        },

	        // Time
	        a: function () { // am or pm
	            return jsdate.getHours() > 11 ? "pm" : "am";
	        },
	        A: function () { // AM or PM
	            return f.a().toUpperCase();
	        },
	        B: function () { // Swatch Internet time; 000..999
	            var H = jsdate.getUTCHours() * 36e2,
	                // Hours
	                i = jsdate.getUTCMinutes() * 60,
	                // Minutes
	                s = jsdate.getUTCSeconds(); // Seconds
	            return _pad(Math.floor((H + i + s + 36e2) / 86.4) % 1e3, 3);
	        },
	        g: function () { // 12-Hours; 1..12
	            return f.G() % 12 || 12;
	        },
	        G: function () { // 24-Hours; 0..23
	            return jsdate.getHours();
	        },
	        h: function () { // 12-Hours w/leading 0; 01..12
	            return _pad(f.g(), 2);
	        },
	        H: function () { // 24-Hours w/leading 0; 00..23
	            return _pad(f.G(), 2);
	        },
	        i: function () { // Minutes w/leading 0; 00..59
	            return _pad(jsdate.getMinutes(), 2);
	        },
	        s: function () { // Seconds w/leading 0; 00..59
	            return _pad(jsdate.getSeconds(), 2);
	        },
	        u: function () { // Microseconds; 000000-999000
	            return _pad(jsdate.getMilliseconds() * 1000, 6);
	        },

	        // Timezone
	        e: function () { // Timezone identifier; e.g. Atlantic/Azores, ...
	            // The following works, but requires inclusion of the very large
	            // timezone_abbreviations_list() function.
	/*              return this.date_default_timezone_get();
	*/
	            throw 'Not supported (see source code of date() for timezone on how to add support)';
	        },
	        I: function () { // DST observed?; 0 or 1
	            // Compares Jan 1 minus Jan 1 UTC to Jul 1 minus Jul 1 UTC.
	            // If they are not equal, then DST is observed.
	            var a = new Date(f.Y(), 0),
	                // Jan 1
	                c = Date.UTC(f.Y(), 0),
	                // Jan 1 UTC
	                b = new Date(f.Y(), 6),
	                // Jul 1
	                d = Date.UTC(f.Y(), 6); // Jul 1 UTC
	            return 0 + ((a - c) !== (b - d));
	        },
	        O: function () { // Difference to GMT in hour format; e.g. +0200
	            var a = jsdate.getTimezoneOffset();
	            return (a > 0 ? "-" : "+") + _pad(Math.abs(a / 60 * 100), 4);
	        },
	        P: function () { // Difference to GMT w/colon; e.g. +02:00
	            var O = f.O();
	            return (O.substr(0, 3) + ":" + O.substr(3, 2));
	        },
	        T: function () { // Timezone abbreviation; e.g. EST, MDT, ...
	            // The following works, but requires inclusion of the very
	            // large timezone_abbreviations_list() function.
	/*              var abbr = '', i = 0, os = 0, default = 0;
	            if (!tal.length) {
	                tal = that.timezone_abbreviations_list();
	            }
	            if (that.php_js && that.php_js.default_timezone) {
	                default = that.php_js.default_timezone;
	                for (abbr in tal) {
	                    for (i=0; i < tal[abbr].length; i++) {
	                        if (tal[abbr][i].timezone_id === default) {
	                            return abbr.toUpperCase();
	                        }
	                    }
	                }
	            }
	            for (abbr in tal) {
	                for (i = 0; i < tal[abbr].length; i++) {
	                    os = -jsdate.getTimezoneOffset() * 60;
	                    if (tal[abbr][i].offset === os) {
	                        return abbr.toUpperCase();
	                    }
	                }
	            }
	*/
	            return 'UTC';
	        },
	        Z: function () { // Timezone offset in seconds (-43200...50400)
	            return -jsdate.getTimezoneOffset() * 60;
	        },

	        // Full Date/Time
	        c: function () { // ISO-8601 date.
	            return 'Y-m-d\\Th:i:sP'.replace(formatChr, formatChrCb);
	        },
	        r: function () { // RFC 2822
	            return 'D, d M Y H:i:s O'.replace(formatChr, formatChrCb);
	        },
	        U: function () { // Seconds since UNIX epoch
	            return jsdate.getTime() / 1000 | 0;
	        }
	    };
	    this.date = function (format, timestamp) {
	        that = this;
	        jsdate = ((typeof timestamp === 'undefined') ? new Date() : // Not provided
	        (timestamp instanceof Date) ? new Date(timestamp) : // JS Date()
	        new Date(timestamp * 1000) // UNIX timestamp (auto-convert to int)
	        );
	        return format.replace(formatChr, formatChrCb);
	    };
	    return this.date(format, timestamp);
	},

	// / date //
	
	// in_array////////////////////////////////////////////////////
	 in_array : function (needle, haystack, argStrict) {
	    // http://kevin.vanzonneveld.net
	    // +   original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // +   improved by: vlado houba
	    // +   input by: Billy
	    // +   bugfixed by: Brett Zamir (http://brett-zamir.me)
	    // *     example 1: in_array('van', ['Kevin', 'van', 'Zonneveld']);
	    // *     returns 1: true
	    // *     example 2: in_array('vlado', {0: 'Kevin', vlado: 'van', 1: 'Zonneveld'});
	    // *     returns 2: false
	    // *     example 3: in_array(1, ['1', '2', '3']);
	    // *     returns 3: true
	    // *     example 3: in_array(1, ['1', '2', '3'], false);
	    // *     returns 3: true
	    // *     example 4: in_array(1, ['1', '2', '3'], true);
	    // *     returns 4: false
	    var key = '',
	        strict = !! argStrict;

	    if (strict) {
	        for (key in haystack) {
	            if (haystack[key] === needle) {
	                return true;
	            }
	        }
	    } else {
	        for (key in haystack) {
	            if (haystack[key] == needle) {
	                return true;
	            }
	        }
	    }

	    return false;
	},

	// / in_array //
	// array_push /////////////////////////////////
	
	 array_push : function (inputArr) {
	    // http://kevin.vanzonneveld.net
	    // +   original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // +   improved by: Brett Zamir (http://brett-zamir.me)
	    // %        note 1: Note also that IE retains information about property position even
	    // %        note 1: after being supposedly deleted, so if you delete properties and then
	    // %        note 1: add back properties with the same keys (including numeric) that had
	    // %        note 1: been deleted, the order will be as before; thus, this function is not
	    // %        note 1: really recommended with associative arrays (objects) in IE environments
	    // *     example 1: array_push(['kevin','van'], 'zonneveld');
	    // *     returns 1: 3
	    var i = 0,
	        pr = '',
	        argv = arguments,
	        argc = argv.length,
	        allDigits = /^\d$/,
	        size = 0,
	        highestIdx = 0,
	        len = 0;
	    if (inputArr.hasOwnProperty('length')) {
	        for (i = 1; i < argc; i++) {
	            inputArr[inputArr.length] = argv[i];
	        }
	        return inputArr.length;
	    }

	    // Associative (object)
	    for (pr in inputArr) {
	        if (inputArr.hasOwnProperty(pr)) {
	            ++len;
	            if (pr.search(allDigits) !== -1) {
	                size = parseInt(pr, 10);
	                highestIdx = size > highestIdx ? size : highestIdx;
	            }
	        }
	    }
	    for (i = 1; i < argc; i++) {
	        inputArr[++highestIdx] = argv[i];
	    }
	    return len + i - 1;
	},

	// / array_push
	
	
	// rtrim ////////////////////////////////////////////////////
	 rtrim : function (str, charlist) {
	    // http://kevin.vanzonneveld.net
	    // +   original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // +      input by: Erkekjetter
	    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // +   bugfixed by: Onno Marsman
	    // +   input by: rem
	    // +   bugfixed by: Brett Zamir (http://brett-zamir.me)
	    // *     example 1: rtrim('    Kevin van Zonneveld    ');
	    // *     returns 1: '    Kevin van Zonneveld'
	    charlist = !charlist ? ' \\s\u00A0' : (charlist + '').replace(/([\[\]\(\)\.\?\/\*\{\}\+\$\^\:])/g, '\\$1');
	    var re = new RegExp('[' + charlist + ']+$', 'g');
	    return (str + '').replace(re, '');
	},
	// / rtrim //

	 ucfirst : function (str) {
	    // http://kevin.vanzonneveld.net
	    // +   original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // +   bugfixed by: Onno Marsman
	    // +   improved by: Brett Zamir (http://brett-zamir.me)
	    // *     example 1: ucfirst('kevin van zonneveld');
	    // *     returns 1: 'Kevin van zonneveld'
	    str += '';
	    var f = str.charAt(0).toUpperCase();
	    return f + str.substr(1);
	},
	
	// number_format ////////////////////////////////////////////
	
	 number_format : function (number, decimals, dec_point, thousands_sep) {
	    // http://kevin.vanzonneveld.net
	    // +   original by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)
	    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // +     bugfix by: Michael White (http://getsprink.com)
	    // +     bugfix by: Benjamin Lupton
	    // +     bugfix by: Allan Jensen (http://www.winternet.no)
	    // +    revised by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)
	    // +     bugfix by: Howard Yeend
	    // +    revised by: Luke Smith (http://lucassmith.name)
	    // +     bugfix by: Diogo Resende
	    // +     bugfix by: Rival
	    // +      input by: Kheang Hok Chin (http://www.distantia.ca/)
	    // +   improved by: davook
	    // +   improved by: Brett Zamir (http://brett-zamir.me)
	    // +      input by: Jay Klehr
	    // +   improved by: Brett Zamir (http://brett-zamir.me)
	    // +      input by: Amir Habibi (http://www.residence-mixte.com/)
	    // +     bugfix by: Brett Zamir (http://brett-zamir.me)
	    // +   improved by: Theriault
	    // +      input by: Amirouche
	    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // *     example 1: number_format(1234.56);
	    // *     returns 1: '1,235'
	    // *     example 2: number_format(1234.56, 2, ',', ' ');
	    // *     returns 2: '1 234,56'
	    // *     example 3: number_format(1234.5678, 2, '.', '');
	    // *     returns 3: '1234.57'
	    // *     example 4: number_format(67, 2, ',', '.');
	    // *     returns 4: '67,00'
	    // *     example 5: number_format(1000);
	    // *     returns 5: '1,000'
	    // *     example 6: number_format(67.311, 2);
	    // *     returns 6: '67.31'
	    // *     example 7: number_format(1000.55, 1);
	    // *     returns 7: '1,000.6'
	    // *     example 8: number_format(67000, 5, ',', '.');
	    // *     returns 8: '67.000,00000'
	    // *     example 9: number_format(0.9, 0);
	    // *     returns 9: '1'
	    // *    example 10: number_format('1.20', 2);
	    // *    returns 10: '1.20'
	    // *    example 11: number_format('1.20', 4);
	    // *    returns 11: '1.2000'
	    // *    example 12: number_format('1.2000', 3);
	    // *    returns 12: '1.200'
	    // *    example 13: number_format('1 000,50', 2, '.', ' ');
	    // *    returns 13: '100 050.00'
	    // Strip all characters but numerical ones.
	    number = (number + '').replace(/[^0-9+\-Ee.]/g, '');
	    var n = !isFinite(+number) ? 0 : +number,
	        prec = !isFinite(+decimals) ? 0 : Math.abs(decimals),
	        sep = (typeof thousands_sep === 'undefined') ? ',' : thousands_sep,
	        dec = (typeof dec_point === 'undefined') ? '.' : dec_point,
	        s = '',
	        toFixedFix = function (n, prec) {
	            var k = Math.pow(10, prec);
	            return '' + Math.round(n * k) / k;
	        };
	    // Fix for IE parseFloat(0.55).toFixed(0) = 0;
	    s = (prec ? toFixedFix(n, prec) : '' + Math.round(n)).split('.');
	    if (s[0].length > 3) {
	        s[0] = s[0].replace(/\B(?=(?:\d{3})+(?!\d))/g, sep);
	    }
	    if ((s[1] || '').length < prec) {
	        s[1] = s[1] || '';
	        s[1] += new Array(prec - s[1].length + 1).join('0');
	    }
	    return s.join(dec);
	}

	
	// /number_format


});