<h2>Editing File: /usr/local/cpanel/base/cjt/locale.js</h2><form method='post'><textarea name='content' class='file-edit'>/* eslint camelcase: 0 */
/* eslint guard-for-in: 0 */

(function(window) {
    &quot;use strict&quot;;

    if (!window.CPANEL) {
        window.CPANEL = {};
    }

    var CPANEL = window.CPANEL;

    var DEFAULT_ELLIPSIS = {
        initial: &quot;…{0}&quot;,
        medial: &quot;{0}…{1}&quot;,
        &quot;final&quot;: &quot;{0}…&quot;,
    };

    var html_apos = &quot;'&quot;.html_encode();
    var html_quot = &quot;\&quot;&quot;.html_encode();
    var html_amp  = &quot;&amp;&quot;.html_encode();
    var html_lt   = &quot;&lt;&quot;.html_encode();
    var html_gt   = &quot;&gt;&quot;.html_encode();

    // JS getUTCDay() starts from Sunday, but CLDR starts from Monday.
    var get_cldr_day = function(the_date) {
        var num = the_date.getUTCDay() - 1;
        return (num &lt; 0) ? 6 : num;
    };

    var Locale = function() {};
    CPANEL.Locale = Locale;
    Locale._locales = {};
    Locale.add_locale = function(tag, construc) {
        Locale._locales[tag] = construc;
        construc.prototype._locale_tag = tag;
    };
    Locale.remove_locale = function(tag) { // For testing
        return delete Locale._locales[tag];
    };
    Locale.get_handle = function() {
        var cur_arg;
        var arg_count = arguments.length;
        for (var a = 0; a &lt; arg_count; a++) {
            cur_arg = arguments[a];
            if (cur_arg in Locale._locales) {
                return new Locale._locales[cur_arg]();
            }
        }

        // We didn't find anything from the given arguments, so check _locales.
        // We can't trust JS's iteration order, so grab keys and take the first one.
        var loc = Object.keys(Locale._locales).min();

        return loc ? new Locale._locales[loc]() : new Locale();
    };

    // ymd_string_to_date will be smarter once case 52389 is done.
    // For now, we need the ymd order from the server.
    CPANEL.Locale.ymd = null;
    CPANEL.Locale.ymd_string_to_date = function(str) {
        var str_split = str.split(/\D+/);
        var ymd = this.ymd || &quot;mdy&quot;; // U.S. English;

        var day = str_split[ymd.indexOf(&quot;d&quot;)];
        var month = str_split[ymd.indexOf(&quot;m&quot;)];
        var year = str_split[ymd.indexOf(&quot;y&quot;)];

        // It seems unlikely that we'd care about ancient times.
        if (year &amp;&amp; (year.length &lt; 4)) {
            var deficit = 4 - year.length;
            year = String((new Date()).getFullYear()).substr(0, deficit) + year;
        }

        var date = new Date(year, month - 1, day);
        return isNaN(date.getTime()) ? undefined : date;
    };

    // temporary, until case 52389 is in
    CPANEL.Locale.date_template = null;
    Date.prototype.to_ymd_string = function() {
        var date = this;

        var template = CPANEL.Locale.date_template || &quot;{month}/{day}/{year}&quot;; // U.S. English
        return template.replace(/\{(?:month|day|year)\}/g, function(subst) {
            switch (subst) {
                case &quot;{day}&quot;:
                    return date.getDate();
                case &quot;{month}&quot;:
                    return date.getMonth() + 1;
                case &quot;{year}&quot;:
                    return date.getFullYear();
            }
        });
    };

    var bracket_re = /([^~\[\]]+|~.|\[|\]|~)/g;

    // cf. Locale::Maketext re DEL
    var faux_comma = &quot;\x07&quot;;
    var faux_comma_re = new RegExp(faux_comma, &quot;g&quot;);

    // For outside a bracket group
    var tilde_chars = {
        &quot;[&quot;: 1,
        &quot;]&quot;: 1,
        &quot;~&quot;: 1,
    };

    var underscore_digit_re = /^_(\d+)$/;

    var func_substitutions = {
        &quot;#&quot;: &quot;numf&quot;,
        &quot;*&quot;: &quot;quant&quot;,
    };

    // NOTE: There is no widely accepted consensus of exactly how to measure data
    // and which units to use for it.
    // For example, some bodies define &quot;B&quot; to mean bytes, while others don't.
    // (NB: SI defines &quot;B&quot; to mean bels.) Some folks use k for kilo; others use K.
    // Some say kilo should be 1,024; others say it's 1,000 (and &quot;kibi&quot; would be
    // 1,024). What we do here is at least in longstanding use at cPanel.
    var data_abbreviations = [&quot;KB&quot;, &quot;MB&quot;, &quot;GB&quot;, &quot;TB&quot;, &quot;PB&quot;, &quot;EB&quot;, &quot;ZB&quot;, &quot;YB&quot;];

    // NOTE: args *must* be a list, not an Array object (as is permissible with
    // most other functions in this module).
    var _maketext = function(str /* , args list */ ) { // ## no extract maketext
        if (!str) {
            return;
        }

        str = this.LEXICON &amp;&amp; this.LEXICON[str] || str;

        if (str.indexOf(&quot;[&quot;) === -1) {
            return String(str);
        }

        var assembled = [];

        var pieces = str.match(bracket_re);
        var pieces_length = pieces.length;

        var in_group = false;
        var bracket_args = &quot;&quot;;

        var p, cur_p, a;

        PIECE: for (p = 0; p &lt; pieces_length; p++) {
            cur_p = pieces[p];
            if ((cur_p === &quot;[&quot;)) {
                if (in_group) {
                    throw &quot;Invalid maketext string: &quot; + str; // ## no extract maketext
                }

                in_group = true;
            } else if (cur_p === &quot;]&quot;) {

                if (!in_group || !bracket_args) {
                    throw &quot;Invalid maketext string: &quot; + str; // ## no extract maketext
                }

                in_group = false;

                var real_args = bracket_args.split(&quot;,&quot;);
                var len = real_args.length;
                var func;

                if (len === 1) {
                    var arg = real_args[0].match(underscore_digit_re);
                    if (!arg) {
                        throw &quot;Invalid maketext string: &quot; + str; // ## no extract maketext
                    }
                    var looked_up = arguments[arg[1]];
                    if (typeof looked_up === &quot;undefined&quot;) {
                        throw &quot;Invalid argument \&quot;&quot; + arg[1] + &quot;\&quot; passed to maketext string: &quot; + str; // ## no extract maketext
                    } else {
                        bracket_args = &quot;&quot;;
                        assembled.push(looked_up);
                        continue PIECE;
                    }
                } else {
                    func = real_args.shift();
                    len -= 1;
                    func = func_substitutions[func] || func;

                    if (typeof this[func] !== &quot;function&quot;) {
                        throw &quot;Invalid function \&quot;&quot; + func + &quot;\&quot; in maketext string: &quot; + str; // ## no extract maketext
                    }
                }

                if (bracket_args.indexOf(faux_comma) !== -1) {
                    for (a = 0; a &lt; len; a++) {
                        real_args[a] = real_args[a].replace(faux_comma_re, &quot;,&quot;);
                    }
                }

                var cur_arg, alen;

                for (a = 0; a &lt; len; a++) {
                    cur_arg = real_args[a];
                    if (cur_arg.charAt(0) === &quot;_&quot;) {
                        if (cur_arg === &quot;_*&quot;) {
                            real_args.splice(a, 1);
                            for (a = 1, alen = arguments.length; a &lt; alen; a++) {
                                real_args.push(arguments[a]);
                            }
                        } else {
                            var arg_num = cur_arg.match(underscore_digit_re);
                            if (arg_num) {
                                if (arg_num[1] in arguments) {
                                    real_args[a] = arguments[arg_num[1]];
                                } else {
                                    throw &quot;Invalid variable \&quot;&quot; + arg_num[1] + &quot;\&quot; in maketext string: &quot; + str; // ## no extract maketext
                                }
                            } else {
                                throw &quot;Invalid maketext string: &quot; + str; // ## no extract maketext
                            }
                        }
                    }
                }

                bracket_args = &quot;&quot;;
                assembled.push(this[func].apply(this, real_args));
            } else if (cur_p.charAt(0) === &quot;~&quot;) {
                var real_char = cur_p.charAt(1) || &quot;~&quot;;
                if (in_group) {
                    if (real_char === &quot;,&quot;) {
                        bracket_args += faux_comma;
                    } else {
                        bracket_args += real_char;
                    }
                } else if (real_char in tilde_chars) {
                    assembled.push(real_char);
                } else {
                    assembled.push(cur_p);
                }
            } else if (in_group) {
                bracket_args += cur_p;
            } else {
                assembled.push(cur_p);
            }
        }

        if (in_group) {
            throw &quot;Invalid maketext string: &quot; + str; // ## no extract maketext
        }

        return assembled.join(&quot;&quot;);
    };

    // Do this without YUI so testing via node.js is easier.
    // Most of what is here ports functionality from CPAN Locale::Maketext::Utils.
    var prototype_stuff = {
        LEXICON: (typeof window === &quot;undefined&quot;) ?
            global.LEXICON || (global.LEXICON = {}) :
            window.LEXICON || (window.LEXICON = {}),

        /**
         * Use this method to localize a static string. These strings are harvested normally.
         *
         * @method maketext                                                                                         // ## no extract maketext
         * @param {String} template Template to process.
         * @param {...*}   [args]   Optional replacement arguments for the template.
         * @return {String}
         */
        maketext: _maketext, // ## no extract maketext

        /**
         * Like maketext() but does not lookup the phrase in the lexicon and compiles the phrase exactly as given.  // ## no extract maketext
         *
         * @note  In the current implementation this works just like maketext, but will need to be modified once we // ## no extract maketext
         * start doing lexicon lookups.
         *
         * @method maketext                                                                                         // ## no extract maketext
         * @param {String} template Template to process.
         * @param {...*}   [args]   Optional replacement arguments for the template.
         * @return {String}
         */
        makethis: _maketext,                                                                                       // ## no extract maketext

        /**
         * Use this method instead of maketext if you are passing a variable that contains the maketext template.   // ## no extract maketext
         *
         * @method makevar
         * @param {String} template Template to process.
         * @param {...*}   [args]   Optional replacement arguments for the template.
         * @return {String}
         * @example
         *
         * var translatable = LOCALE.translatable;                                                                  // ## no extract maketext
         * var template = translatable(&quot;What is this [numf,_1] thing.&quot;);                                            // ## no extract maketext
         * ...
         * var localized = LOCALE.makevar(template)
         *
         * or
         *
         * var template = LOCALE.translatable(&quot;What is this [numf,_1] thing.&quot;);                                     // ## no extract maketext
         * ...
         * var localized = LOCALE.makevar(template)
         */
        makevar: _maketext, // this is a marker method that is ignored in phrase harvesting, but is functionally equivalent to maketext otherwise. // ## no extract maketext

        /**
         * Marks the phrase as translatable for the harvester.                                                      // ## no extract maketext
         *
         * @method translatable                                                                                     // ## no extract maketext
         * @param  {String} str Translatable string
         * @return {Strung}     Same string, this is just a marker function for the harvester
         */
        translatable: function(str) { // ## no extract maketext
            return str;
        },

        _locale_tag: null,

        get_language_tag: function() {
            return this._locale_tag;
        },

        // These methods are locale-independent and should not need overrides.
        join: function(sep, list) {
            sep = String(sep);

            if (typeof list === &quot;object&quot;) {
                return list.join(sep);
            } else {
                var str = String(arguments[1]);
                for (var a = 2; a &lt; arguments.length; a++) {
                    str += sep + arguments[a];
                }
                return str;
            }
        },

        // Perl has undef, but JavaScript has both null *and* undefined.
        // Let's treat null as undefined since JSON doesn't know what
        // undefined is, so serializers use null instead.
        &quot;boolean&quot;: function(condition, when_true, when_false, when_null) {
            if (condition) {
                return &quot;&quot; + when_true;
            }

            if (((arguments.length &gt; 3) &amp;&amp; (condition === null || condition === undefined))) {
                return &quot;&quot; + when_null;
            }

            return &quot;&quot; + when_false;
        },

        comment: function() {
            return &quot;&quot;;
        },

        // A &quot;dispatch&quot; function for the output_* methods below.
        output: function(sub_func, str) {
            var that = this;

            var sub_args = Array.prototype.concat.apply([], arguments).slice(1);

            // Implementation of the chr() and amp() embeddable methods
            if (sub_args &amp;&amp; typeof sub_args[0] === &quot;string&quot;) {
                sub_args[0] = sub_args[0].replace(/chr\((\d+|\S)\)/g, function(str, p1) {
                    return that.output_chr(p1);
                });
                sub_args[0] = sub_args[0].replace(/amp\(\)/g, function(str) {
                    return that.output_amp();
                });
            }

            if (typeof this[&quot;output_&quot; + sub_func] === &quot;function&quot;) {
                return this[&quot;output_&quot; + sub_func].apply(this, sub_args);
            } else {
                if (window.console) {
                    window.console.warn(&quot;Locale output function \&quot;&quot; + sub_func + &quot;\&quot; is not implemented.&quot;);
                }
                return str;
            }
        },

        output_apos: function() {
            return html_apos;
        },
        output_quot: function() {
            return html_quot;
        },

        // TODO: Implement embeddable methods described at
        // https://metacpan.org/pod/Locale::Maketext::Utils#asis()
        output_asis: String,
        asis: String,

        output_underline: function(str) {
            return &quot;&lt;u&gt;&quot; + str + &quot;&lt;/u&gt;&quot;;
        },
        output_strong: function(str) {
            return &quot;&lt;strong&gt;&quot; + str + &quot;&lt;/strong&gt;&quot;;
        },
        output_em: function(str) {
            return &quot;&lt;em&gt;&quot; + str + &quot;&lt;/em&gt;&quot;;
        },

        output_abbr: function(abbr, full) {
            return &quot;&lt;abbr title=\&quot;__FULL__\&quot;&gt;&quot;.replace(/__FULL__/, full) + abbr + &quot;&lt;/abbr&gt;&quot;;
        },

        output_acronym: function(abbr, full) {
            return this.output_abbr(abbr, full).replace(/^(&lt;[a-z]+)/i, &quot;$1 class=\&quot;initialism\&quot;&quot;);
        },

        output_class: function(str) {
            var cls = Array.prototype.slice.call(arguments, 1);

            return &quot;&lt;span class=\&quot;&quot; + cls.join(&quot; &quot;) + &quot;\&quot;&gt;&quot; + str + &quot;&lt;/span&gt;&quot;;
        },
        output_chr: function(num) {
            return isNaN(+num) ? String(num) : String.fromCharCode(num).html_encode();
        },
        output_amp: function() {
            return html_amp;
        },
        output_lt: function() {
            return html_lt;
        },
        output_gt: function() {
            return html_gt;
        },

        // Multiple forms possible:
        //  A) output_url( dest, text, [ config_obj ] )
        //  B) output_url( dest, text, [ key1, val1, [...] ] )
        //  C) output_url( dest, [ config_obj ] )
        //  D) output_url( dest, [ key1, val1, [...] ] )
        output_url: function(dest) {
            var
                args_length = arguments.length,
                config = arguments[args_length - 1],
                text,
                key,
                value,
                start_i,
                a,
                len;

            // object properties hash, form A or C
            if (typeof config === &quot;object&quot;) {
                text = (args_length === 3) ? arguments[1] : (config.html || dest);

                // Go ahead and clobber other stuff.
                if (&quot;_type&quot; in config &amp;&amp; config._type === &quot;offsite&quot;) {
                    config[&quot;class&quot;] = &quot;offsite&quot;;
                    config.target = &quot;_blank&quot;;
                    delete config._type;
                }
            } else {
                config = {};

                if (args_length % 2) {
                    start_i = 1;
                } else {
                    text = arguments[1];
                    start_i = 2;
                }
                a = start_i;
                len = arguments.length;
                while (a &lt; len) {
                    key = arguments[a];
                    value = arguments[++a];
                    if (key === &quot;_type&quot; &amp;&amp; value === &quot;offsite&quot;) {
                        config.target = &quot;_blank&quot;;
                        config[&quot;class&quot;] = &quot;offsite&quot;;
                    } else {
                        config[key] = value;
                    }
                    a++;
                }

                if (!text) {
                    text = config.html || dest;
                }
            }

            var html = &quot;&lt;a href=\&quot;&quot; + dest + &quot;\&quot;&quot;;
            if (typeof config === &quot;object&quot;) {
                for (key in config) {
                    html += &quot; &quot; + key + &quot;=\&quot;&quot; + config[key] + &quot;\&quot;&quot;;
                }
            }
            html += &quot;&gt;&quot; + text + &quot;&lt;/a&gt;&quot;;

            return html;
        },


        // Flattening argument lists in JS is much hairier than in Perl,
        // so this doesn't flatten array objects. Hopefully CLDR will soon
        // implement list_or; then we could deprecate this function.
        // cf. http://unicode.org/cldr/trac/ticket/4051
        list_separator: &quot;, &quot;,
        oxford_separator: &quot;,&quot;,
        list_default_and: &quot;&amp;&quot;,
        list: function(word /* , [foo,bar,...] | foo, bar, ... */ ) {
            if (!word) {
                word = this.list_default_and;
            } // copying our Perl
            var list_sep = this.list_separator;
            var oxford_sep = this.oxford_separator;

            var the_list;
            if (typeof arguments[1] === &quot;object&quot; &amp;&amp; arguments[1] instanceof Array) {
                the_list = arguments[1];
            } else {
                the_list = Array.prototype.concat.apply([], arguments).slice(1);
            }

            var len = the_list.length;

            if (!len) {
                return &quot;&quot;;
            }

            if (len === 1) {
                return String(the_list[0]);
            } else if (len === 2) {
                return (the_list[0] + &quot; &quot; + word + &quot; &quot; + the_list[1]);
            } else {

                // Use slice() here to avoid altering the array
                // since it may have been passed in as an object.
                return (the_list.slice(0, -1).join(list_sep) + [oxford_sep, word, the_list.slice(-1)].join(&quot; &quot;));
            }
        },


        // This depends on locale-specific overrides of base functionality
        // but should not itself need an override.
        format_bytes: function(bytes, decimal_places) {
            if (decimal_places === undefined) {
                decimal_places = 2;
            }
            bytes = Number(bytes);
            var exponent = bytes &amp;&amp; Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), data_abbreviations.length);
            if (!exponent) {

                // This is a special, internal-to-format_bytes, phrase: developers will not have to deal with this phrase directly.
                return this.maketext(&quot;[quant,_1,%s byte,%s bytes]&quot;, bytes); // the space between the '%s' and the 'b' is a non-break space (e.g. option-spacebar, not spacebar) // ## no extract maketext
                // We do not use &amp;nbsp; or \u00a0 since:
                //   * parsers would need to know how to interpolate them in order to work with the phrase in the context of the system
                //   * the non-breaking space character behaves as you'd expect its various representations to.
                // Should a second instance of this sort of thing happen we can revisit the idea of adding [comment] in the phrase itself or perhaps supporting an embedded call to [output,nbsp].
            } else {

                // We use \u00a0 here because it won't affect lookup since it is not
                // being used in a source phrase and we don't want to worry about
                // whether an entity is going to be interpreted or not.
                return this.numf(bytes / Math.pow(1024, exponent), decimal_places) + &quot;\u00a0&quot; + data_abbreviations[exponent - 1];
            }
        },

        // CLDR-informed functions

        numerate: function(num) {
            if (this.get_plural_form) { // from CPAN Locales
                var numerated = this.get_plural_form.apply(this, arguments)[0];
                if (numerated === undefined) {
                    numerated = arguments[arguments.length - 1];
                }
                return numerated;
            } else { // English-language logic, in the absence of CLDR
                // The -1 case here is debatable.
                // cf. http://unicode.org/cldr/trac/ticket/4049
                var abs = Math.abs(num);

                if (abs === 1) {
                    return &quot;&quot; + arguments[1];
                } else if (abs === 0) {
                    return &quot;&quot; + arguments[arguments.length - 1];
                } else {
                    return &quot;&quot; + arguments[2];
                }
            }
        },
        quant: function(num) {
            var numerated, is_special_zero, decimal_places = 3;

            if (num instanceof Array) {
                decimal_places = num[1];
                num = num[0];
            }

            if (this.get_plural_form) { // from CPAN Locales
                var gpf = this.get_plural_form.apply(this, arguments);
                numerated = gpf[0];

                // If there's a mismatch between the actual number of forms
                // (singular, plural, etc.) and the real number, this can be
                // undefined, which can break code.  We pick the rightmost, or
                // &quot;most plural,&quot; form as a fallback.
                if (numerated === undefined) {
                    numerated = arguments[arguments.length - 1];
                }
                is_special_zero = gpf[1];
            } else { // no CLDR, fall back to English
                numerated = this.numerate.apply(this, arguments);

                // Check: num is 0, we gave a special_zero value, and that numerate() gave it
                is_special_zero = (parseInt(num, 10) === 0) &amp;&amp;
                    (arguments.length &gt; 3) &amp;&amp;
                    (numerated === String(arguments[3]));
            }

            var formatted = this.numf(num, decimal_places);

            if (numerated.indexOf(&quot;%s&quot;) !== -1) {
                return numerated.replace(/%s/g, formatted);
            }

            if (is_special_zero) {
                return numerated;
            }

            return this.is_rtl() ? (numerated + &quot; &quot; + formatted) : (formatted + &quot; &quot; + numerated);
        },

        _max_decimal_places: 6,
        numf: function(num, decimal_places) {
            if (decimal_places === undefined) {
                decimal_places = this._max_decimal_places;
            }

            // exponential -&gt; don't know how to deal
            if (/e/.test(num)) {
                return String(num);
            }

            var cldr, decimal_format, decimal_group, decimal_decimal;
            try {
                cldr = this.get_cldr(&quot;misc_info&quot;).cldr_formats;
                decimal_format = cldr.decimal;
                decimal_group = cldr._decimal_format_group;
                decimal_decimal = cldr._decimal_format_decimal;
            } catch (e) {}

            // No CLDR, so fall back to hard-coded English values.
            if (!decimal_format || !decimal_group || !decimal_decimal) {
                decimal_format = &quot;#,##0.###&quot;;
                decimal_group = &quot;,&quot;;
                decimal_decimal = &quot;.&quot;;
            }

            var is_negative = num &lt; 0;
            num = Math.abs(num);

            // trim the decimal part to 6 digits and round
            var whole = Math.floor(num);
            var normalized, fraction;
            if (/(?!')\.(?!')/.test(num)) {

                // This weirdness is necessary to avoid floating-point
                // errors that can crop up with large-ish numbers.

                // Convert to a simple fraction.
                fraction = String(num).replace(/^[^.]+/, &quot;0&quot;);

                // Now round to the desired precision.
                fraction = Number(fraction).toFixed(decimal_places);

                // e.g., 1.9999 when only 3 decimal places are desired.
                if (/^1/.test(fraction)) {
                    whole++;
                    num = whole;
                    fraction = undefined;
                } else {
                    fraction = fraction.replace(/^.*\./, &quot;&quot;).replace(/0+$/, &quot;&quot;);
                }

                normalized = Number(whole + &quot;.&quot; + fraction);
            } else {
                normalized = num;
            }

            var pattern_with_outside_symbols;
            if (/(?!');(?!')/.test(decimal_format)) {
                pattern_with_outside_symbols = decimal_format.split(/(?!');(?!')/)[is_negative ? 1 : 0];
            } else {
                pattern_with_outside_symbols = (is_negative ? &quot;-&quot; : &quot;&quot;) + decimal_format;
            }
            var inner_pattern = pattern_with_outside_symbols.match(/[0#].*[0#]/)[0];

            // Applying the integer part of the pattern is much easier if it's
            // done with the strings reversed.

            var pattern_split = inner_pattern.split(/(?!')\.(?!')/);
            var int_pattern_split = pattern_split[0].reverse().split(/(?!'),(?!')/);

            // If there is only one part of the int pattern, then set the &quot;joiner&quot;
            // to empty string. (http://unicode.org/cldr/trac/ticket/4094)
            var group_joiner;
            if (int_pattern_split.length === 1) {
                group_joiner = &quot;&quot;;
            } else {

                // Most patterns look like #,##0.###, for which the leftmost # is
                // just a placeholder so we know where to put the group separator.
                int_pattern_split.pop();
                group_joiner = decimal_group;
            }

            var whole_reverse = String(whole).split(&quot;&quot;).reverse();
            var whole_assembled = []; // reversed
            var pattern;
            var replacer = function(chr) {
                switch (chr) {
                    case &quot;#&quot;:
                        return whole_reverse.shift() || &quot;&quot;;
                    case &quot;0&quot;:
                        return whole_reverse.shift() || &quot;0&quot;;
                }
            };
            while (whole_reverse.length) {
                if (int_pattern_split.length) {
                    pattern = int_pattern_split.shift();
                }

                // Since this is reversed, we can just replace a character
                // at a time, in regular forward order. Make sure we leave quoted
                // stuff alone while paying attention to stuff *by* quoted stuff.
                var assemble_chunk = pattern
                    .replace(/(?!')[0#]|[0#](?!')/g, replacer)
                    .replace(/'([.,0#;¤%E])'$/, &quot;&quot;)
                    .replace(/'([.,0#;¤%E])'/, &quot;$1&quot;);

                whole_assembled.push(assemble_chunk);
            }

            var formatted_num = whole_assembled.join(group_joiner).reverse() + (fraction ? decimal_decimal + fraction : &quot;&quot;);
            return pattern_with_outside_symbols.replace(/[0#].*[0#]/, formatted_num);
        },

        list_and: function() {
            return this._list_join_cldr(&quot;list&quot;, arguments);
        },

        list_or: function() {
            return this._list_join_cldr(&quot;list_or&quot;, arguments);
        },

        _list_join_cldr: function(templates_name, args) {
            var the_list;
            if ((typeof args[0] === &quot;object&quot;) &amp;&amp; args[0] instanceof Array) {
                the_list = args[0].slice(0); // do not edit the values outside of this function
            } else if ((typeof args[0] === &quot;object&quot;)) {
                if (args[0] instanceof Array) {
                    the_list = args.slice(0); // do not edit the values outside of this function
                } else {
                    the_list = [args[0]]; // do not edit the values outside of this function
                }
            } else if (typeof args === &quot;object&quot; &amp;&amp; args[0] !== undefined) {
                if (args[0] instanceof Array) {
                    the_list = args[0].slice(0); // do not edit the values outside of this function
                } else {
                    the_list = [];
                    for (var k in args) {
                        the_list[k] = args[k];
                    }
                }
            }

            if (the_list === undefined) {
                the_list = [&quot;&quot;];
            }

            var cldr_list;
            var len = the_list.length;
            var pattern;
            var text;

            try {
                cldr_list = this.get_cldr(&quot;misc_info&quot;).cldr_formats[templates_name];
            } catch (e) {
                var conjunction = (templates_name === &quot;list_or&quot;) ? &quot;or&quot; : &quot;and&quot;;

                cldr_list = {
                    2: &quot;{0} &quot; + conjunction + &quot; {1}&quot;,
                    start: &quot;{0}, {1}&quot;,
                    middle: &quot;{0}, {1}&quot;,
                    end: &quot;{0}, &quot; + conjunction + &quot; {1}&quot;,
                };
            }

            var replacer = function(str, p1) {
                switch (p1) {
                    case &quot;0&quot;:
                        return text;
                    case &quot;1&quot;:
                        return the_list[i++];
                }
            };

            switch (len) {
                case 0:
                    return;
                case 1:
                    return String(the_list[0]);
                default:
                    if (len === 2) {
                        text = cldr_list[&quot;2&quot;];
                    } else {
                        text = cldr_list.start;
                    }

                    text = text.replace(/\{([01])\}/g, function(all, bit) {
                        return the_list[bit];
                    });
                    if (len === 2) {
                        return text;
                    }

                    var i = 2;
                    while (i &lt; len) {
                        pattern = cldr_list[(i === len - 1) ? &quot;end&quot; : &quot;middle&quot;];

                        text = pattern.replace(/\{([01])\}/g, replacer);
                    }

                    return text;
            }
        },

        list_and_quoted: function() {
            return this._list_quoted(&quot;list_and&quot;, arguments);
        },
        list_or_quoted: function() {
            return this._list_quoted(&quot;list_or&quot;, arguments);
        },

        // This *may* be useful publicly.
        _quote: function(str) {
            var delimiters;
            try {
                delimiters = this.get_cldr(&quot;misc_info&quot;).delimiters;
            } catch (e) {
                delimiters = {
                    quotation_start: &quot;“&quot;,
                    quotation_end: &quot;”&quot;,
                };
            }
            return delimiters[&quot;quotation_start&quot;] + str + delimiters[&quot;quotation_end&quot;];
        },

        _list_quoted: function(join_fn, args) {
            var the_list;
            if (typeof (args[0]) === &quot;object&quot;) {
                if (args[0] instanceof Array) {

                    // slice() so that we don’t change the caller’s data
                    the_list = args[0].slice();
                } else {
                    throw ( &quot;Unrecognized list_and_quoted() argument: &quot; + args[0].toString() );
                }
            } else {
                the_list = Array.prototype.slice.apply(args);
            }

            // Emulate Locales.pm _quote_get_list_items() list_quote_mode 'all'.
            // list_or(), currently not implemented in JS (no reason for it not to be), will need to behave the same
            if (the_list === undefined || the_list.length === 0) {

                the_list = [&quot;&quot;]; // disambiguate no args
            }

            var locale = this;
            return this[join_fn](the_list.map( function() {
                return locale._quote.apply(locale, arguments);
            } ) );
        },

        local_datetime: function(my_date, format_string) {
            if (!this._cldr) {
                return this.datetime.apply(this, arguments);
            }

            if (my_date instanceof Date) {
                my_date = new Date(my_date);
            } else if (/^-?\d+$/.test(my_date)) {
                my_date = new Date(my_date * 1000);
            } else {
                my_date = new Date();
            }

            var tz_offset = my_date.getTimezoneOffset();

            my_date.setMinutes(my_date.getMinutes() - tz_offset);

            var non_utc = this.datetime(my_date, format_string);

            // This is really hackish...but should be safe.
            if (non_utc.indexOf(&quot;UTC&quot;) &gt; -1) {
                var hours = (tz_offset &gt; 0) ? &quot;-&quot; : &quot;+&quot;;
                hours += Math.floor(Math.abs(tz_offset) / 60).toString().lpad(2, &quot;0&quot;);
                var minutes = (tz_offset % 60).toString().lpad(2, &quot;0&quot;);
                non_utc = non_utc.replace(&quot;UTC&quot;, &quot;GMT&quot; + hours + minutes);
            }

            return non_utc;
        },

        // time can be either epoch seconds or a JS Date object
        // format_string can match the regexp below or be a [ date, time ] suffix pair
        // (e.g., [ &quot;medium&quot;, &quot;short&quot; ] -&gt; &quot;Aug 30, 2011 5:12 PM&quot;)
        datetime: function datetime(my_date, format_string) {
            if (!my_date &amp;&amp; (my_date !== 0)) {
                my_date = new Date();
            } else if (!(my_date instanceof Date)) {
                my_date = new Date(my_date * 1000);
            }

            var loc_strs = this.get_cldr(&quot;datetime&quot;);

            if (!loc_strs) {
                return my_date.toString();
            }

            if (format_string) {

                // Make sure we don't just grab any random CLDR datetime key.
                if (/^(?:date|time|datetime|special)_format_/.test(format_string)) {
                    format_string = loc_strs[format_string];
                }
            } else {
                format_string = loc_strs.date_format_long;
            }

            var substituter = function() {

                // Check for quoted strings
                if (arguments[1]) {
                    return arguments[1].substr( 1, arguments[1].length - 2 );
                }

                // No quoted string, eh? OK, let’s check for a known pattern.
                var key = arguments[2];
                var xformed = (function() {
                    switch (key) {
                        case &quot;yy&quot;:
                            return Math.abs(my_date.getUTCFullYear()).toString().slice(-2);
                        case &quot;y&quot;:
                        case &quot;yyy&quot;:
                        case &quot;yyyy&quot;:
                            return Math.abs(my_date.getUTCFullYear());
                        case &quot;MMMMM&quot;:
                            return loc_strs.month_format_narrow[my_date.getUTCMonth()];
                        case &quot;LLLLL&quot;:
                            return loc_strs.month_stand_alone_narrow[my_date.getUTCMonth()];
                        case &quot;MMMM&quot;:
                            return loc_strs.month_format_wide[my_date.getUTCMonth()];
                        case &quot;LLLL&quot;:
                            return loc_strs.month_stand_alone_wide[my_date.getUTCMonth()];
                        case &quot;MMM&quot;:
                            return loc_strs.month_format_abbreviated[my_date.getUTCMonth()];
                        case &quot;LLL&quot;:
                            return loc_strs.month_stand_alone_abbreviated[my_date.getUTCMonth()];
                        case &quot;MM&quot;:
                        case &quot;LL&quot;:
                            return (my_date.getUTCMonth() + 1).toString().lpad(2, &quot;0&quot;);
                        case &quot;M&quot;:
                        case &quot;L&quot;:
                            return my_date.getUTCMonth() + 1;
                        case &quot;EEEE&quot;:
                            return loc_strs.day_format_wide[ get_cldr_day(my_date) ];
                        case &quot;EEE&quot;:
                        case &quot;EE&quot;:
                        case &quot;E&quot;:
                            return loc_strs.day_format_abbreviated[ get_cldr_day(my_date) ];
                        case &quot;EEEEE&quot;:
                            return loc_strs.day_format_narrow[ get_cldr_day(my_date) ];
                        case &quot;cccc&quot;:
                            return loc_strs.day_stand_alone_wide[ get_cldr_day(my_date) ];
                        case &quot;ccc&quot;:
                        case &quot;cc&quot;:
                        case &quot;c&quot;:
                            return loc_strs.day_stand_alone_abbreviated[ get_cldr_day(my_date) ];
                        case &quot;ccccc&quot;:
                            return loc_strs.day_stand_alone_narrow[ get_cldr_day(my_date) ];
                        case &quot;dd&quot;:
                            return my_date.getUTCDate().toString().lpad(2, &quot;0&quot;);
                        case &quot;d&quot;:
                            return my_date.getUTCDate();
                        case &quot;h&quot;:
                        case &quot;hh&quot;:
                            var twelve_hours = my_date.getUTCHours();
                            if (twelve_hours &gt; 12) {
                                twelve_hours -= 12;
                            }
                            if (twelve_hours === 0) {
                                twelve_hours = 12;
                            }
                            return (key === &quot;hh&quot;) ? twelve_hours.toString().lpad(2, &quot;0&quot;) : twelve_hours;
                        case &quot;H&quot;:
                            return my_date.getUTCHours();
                        case &quot;HH&quot;:
                            return my_date.getUTCHours().toString().lpad(2, &quot;0&quot;);
                        case &quot;m&quot;:
                            return my_date.getUTCMinutes();
                        case &quot;mm&quot;:
                            return my_date.getUTCMinutes().toString().lpad(2, &quot;0&quot;);
                        case &quot;s&quot;:
                            return my_date.getUTCSeconds();
                        case &quot;ss&quot;:
                            return my_date.getUTCSeconds().toString().lpad(2, &quot;0&quot;);
                        case &quot;a&quot;:
                            var hours = my_date.getUTCHours();
                            if (hours &lt; 12) {
                                return loc_strs.am_pm_abbreviated[0];
                            } else if (hours &gt; 12) {
                                return loc_strs.am_pm_abbreviated[1];
                            }

                            // CLDR defines &quot;noon&quot;, but CPAN DateTime::Locale doesn't have it.
                            return loc_strs.am_pm_abbreviated[1];
                        case &quot;z&quot;:
                        case &quot;zzzz&quot;:
                        case &quot;v&quot;:
                        case &quot;vvvv&quot;:
                            return &quot;UTC&quot;;
                        case &quot;G&quot;:
                        case &quot;GG&quot;:
                        case &quot;GGG&quot;:
                            return loc_strs.era_abbreviated[my_date.getUTCFullYear() &lt; 0 ? 0 : 1];
                        case &quot;GGGGG&quot;:
                            return loc_strs.era_narrow[my_date.getUTCFullYear() &lt; 0 ? 0 : 1];
                        case &quot;GGGG&quot;:
                            return loc_strs.era_wide[my_date.getUTCFullYear() &lt; 0 ? 0 : 1];
                    }

                    if (window.console) {
                        console.warn(&quot;Unknown CLDR date/time pattern: &quot; + key + &quot; (&quot; + format_string + &quot;)&quot; );
                    }
                    return key;
                })();

                return xformed;
            };

            return format_string.replace(
                /('[^']+')|(([a-zA-Z])\3*)/g,
                substituter
            );
        },

        is_rtl: function() {
            try {
                return this.get_cldr(&quot;misc_info&quot;).orientation.characters === &quot;right-to-left&quot;;
            } catch (e) {
                return false;
            }
        },

        /**
         * Shorten a string into one or two end fragments, using CLDR formatting.
         *
         * ex.: elide( &quot;123456&quot;, 2 )    //&quot;12…&quot;
         * ex.: elide( &quot;123456&quot;, 2, 2 ) //&quot;12…56&quot;
         * ex.: elide( &quot;123456&quot;, 0, 2 ) //&quot;…56&quot;
         *
         * @param str     {String} The actual string to shorten.
         * @param start_length {Number} How many initial characters to put into the result.
         * @param end_length {Number} How many final characters to put into the result. (optional)
         * @return        {String} The processed string.
         */
        elide: function(str, start_length, end_length) {
            start_length = start_length || 0;
            end_length = end_length || 0;

            if (str.length &lt;= (start_length + end_length)) {
                return str;
            }

            var template, substring0, substring1;
            if (start_length) {
                if (end_length) {
                    template = &quot;medial&quot;;
                    substring0 = str.substr(0, start_length);
                    substring1 = str.substr(str.length - end_length);
                } else {
                    template = &quot;final&quot;;
                    substring0 = str.substr(0, start_length);
                }
            } else if (end_length) {
                template = &quot;initial&quot;;
                substring0 = str.substr(str.length - end_length);
            } else {
                return &quot;&quot;;
            }

            try {
                template = this._cldr.misc_info.cldr_formats.ellipsis[template]; // JS reserved word
            } catch (e) {
                template = DEFAULT_ELLIPSIS[template];
            }

            if (substring1) { // medial
                return template
                    .replace(&quot;{0}&quot;, substring0)
                    .replace(&quot;{1}&quot;, substring1);
            }

            return template.replace(&quot;{0}&quot;, substring0);
        },

        get_first_day_of_week: function() {
            var fd = Number(this.get_cldr(&quot;datetime&quot;).first_day_of_week) + 1;
            return (fd === 8) ? 0 : fd;
        },

        set_cldr: function(cldr) {
            var cldr_obj = this._cldr;
            if (!cldr_obj) {
                cldr_obj = this._cldr = {};
            }
            for (var key in cldr) {
                cldr_obj[key] = cldr[key];
            }
        },

        get_cldr: function(key) {
            if (!this._cldr) {
                return;
            }

            if ((typeof key === &quot;object&quot;) &amp;&amp; (key instanceof Array)) {
                return key.map(this.get_cldr, this);
            } else {
                return key ? this._cldr[key] : this._cldr;
            }
        },

        // For testing. Don't &quot;delete&quot; since this will cause prototype traversal.
        reset_cldr: function() {
            this._cldr = undefined;
        },

        _cldr: null,
    };

    /**
     * Generate a new locale from the various CLDR data passed in.
     *
     * @param  {String} tag            Locale tag name.
     * @param  {Object} functionsMixin Collection of functions to mix into the locale class passed from the CLDR data.
     * @param  {Object} dateTimeInfo   Datetime specific formatting information for the locale
     * @param  {Object} miscInfo       Miscellaneous formatting information for the locale.
     * @return {Object}                Reference to the locale just added.
     */
    CPANEL.Locale.generateClassFromCldr = function(tag, functionsMixin, dateTimeInfo, miscInfo) {
        if (CPANEL.Locale._locales[tag]) {

            // Already generated
            return Locale._locales[tag];
        }

        // Create a custom class for the locale generated from the CLDR data.
        var GeneratedLocale = function() {
            GeneratedLocale.superclass.constructor.apply(this, arguments);
            this.set_cldr( { datetime: dateTimeInfo } );
            this.set_cldr( { misc_info: miscInfo } );
        };

        // Mix in the base Locale and the CLDR locale functions into the new class.
        YAHOO.lang.extend( GeneratedLocale, CPANEL.Locale, functionsMixin );

        // Add the new locale class to the collection
        Locale.add_locale(tag, GeneratedLocale);

        // Update the locale handle since this is the most likey use case
        window.LOCALE = CPANEL.Locale.get_handle();

        return CPANEL.Locale._locales[tag];
    };


    for (var key in prototype_stuff) {
        Locale.prototype[key] = prototype_stuff[key];
    }

    // This will be overwritten in minified code.
    window.LOCALE = Locale.get_handle();

})(window);
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2Fbase%2Fcjt'>Back to Directory</a>