text: /******************************************************************************
   * jquery.i18n.properties
   *
   * Dual licensed under the GPL (http://dev.jquery.com/browser/trunk/jquery/GPL-LICENSE.txt) and
   * MIT (http://dev.jquery.com/browser/trunk/jquery/MIT-LICENSE.txt) licenses.
   *
   * @version     1.1.x
   * @author      Nuno Fernandes
   *              Matthew Lohbihler
   * @url         www.codingwithcoffee.com
   * @inspiration Localisation assistance for jQuery (http://keith-wood.name/localisation.html)
   *              by Keith Wood (kbwood{at}iinet.com.au) June 2007
   *
   *****************************************************************************/
  
  (function ($) {
    $.i18n = {};
  
    /** Map holding bundle keys (if mode: 'map') */
    $.i18n.map = {};
  
    /**
     * Load and parse message bundle files (.properties),
     * making bundles keys available as javascript variables.
     *
     * i18n files are named <name>.js, or <name>_<language>.js or <name>_<language>_<country>.js
     * Where:
     *      The <language> argument is a valid ISO Language Code. These codes are the lower-case,
     *      two-letter codes as defined by ISO-639. You can find a full list of these codes at a
     *      number of sites, such as: http://www.loc.gov/standards/iso639-2/englangn.html
     *      The <country> argument is a valid ISO Country Code. These codes are the upper-case,
     *      two-letter codes as defined by ISO-3166. You can find a full list of these codes at a
     *      number of sites, such as: http://www.iso.ch/iso/en/prods-services/iso3166ma/02iso-3166-code-lists/list-en1.html
     *
     * Sample usage for a bundles/Messages.properties bundle:
     * $.i18n.properties({
   *      name:      'Messages',
   *      language:  'en_US',
   *      path:      'bundles'
   * });
     * @param  name      (string/string[], optional) names of file to load (eg, 'Messages' or ['Msg1','Msg2']). Defaults to "Messages"
     * @param  language    (string, optional) language/country code (eg, 'en', 'en_US', 'pt_PT'). if not specified, language reported by the browser will be used instead.
     * @param  path      (string, optional) path of directory that contains file to load
     * @param  mode      (string, optional) whether bundles keys are available as JavaScript variables/functions or as a map (eg, 'vars' or 'map')
     * @param  cache        (boolean, optional) whether bundles should be cached by the browser, or forcibly reloaded on each page load. Defaults to false (i.e. forcibly reloaded)
     * @param  encoding  (string, optional) the encoding to request for bundles. Property file resource bundles are specified to be in ISO-8859-1 format. Defaults to UTF-8 for backward compatibility.
     * @param  callback     (function, optional) callback function to be called after script is terminated
     */
    $.i18n.properties = function (settings) {
      // set up settings
      var defaults = {
        name: 'Messages',
        language: '',
        path: '',
        mode: 'vars',
        cache: false,
        encoding: 'UTF-8',
        callback: null
      };
      settings = $.extend(defaults, settings);
      if (settings.language === null || settings.language == '') {
        settings.language = $.i18n.browserLang();
      }
      if (settings.language === null) {
        settings.language = '';
      }
  
      // load and parse bundle files
      var files = getFiles(settings.name);
      for (var i = 0; i < files.length; i++) {
        // 1. load base (eg, Messages.properties)
        loadAndParseFile(settings.path + files[i] + '.properties', settings);
        // 2. with language code (eg, Messages_pt.properties)
        if (settings.language.length >= 2) {
          loadAndParseFile(settings.path + files[i] + '_' + settings.language.substring(0, 2) + '.properties', settings);
        }
        // 3. with language code and country code (eg, Messages_pt_PT.properties)
        if (settings.language.length >= 5) {
          loadAndParseFile(settings.path + files[i] + '_' + settings.language.substring(0, 5) + '.properties', settings);
        }
      }
  
      // call callback
      if (settings.callback) {
        settings.callback();
      }
    };
  
  
    /**
     * When configured with mode: 'map', allows access to bundle values by specifying its key.
     * Eg, jQuery.i18n.prop('com.company.bundles.menu_add')
     */
    $.i18n.prop = function (key /* Add parameters as function arguments as necessary  */) {
      var value = $.i18n.map[key];
      if (value == null)
        return '[' + key + ']';
  
      var phvList;
      if (arguments.length == 2 && $.isArray(arguments[1]))
      // An array was passed as the only parameter, so assume it is the list of place holder values.
        phvList = arguments[1];
  
      // Place holder replacement
      /**
       * Tested with:
       *   test.t1=asdf ''{0}''
       *   test.t2=asdf '{0}' '{1}'{1}'zxcv
       *   test.t3=This is \"a quote" 'a''{0}''s'd{fgh{ij'
       *   test.t4="'''{'0}''" {0}{a}
       *   test.t5="'''{0}'''" {1}
       *   test.t6=a {1} b {0} c
       *   test.t7=a 'quoted \\ s\ttringy' \t\t x
       *
       * Produces:
       *   test.t1, p1 ==> asdf 'p1'
       *   test.t2, p1 ==> asdf {0} {1}{1}zxcv
       *   test.t3, p1 ==> This is "a quote" a'{0}'sd{fgh{ij
       *   test.t4, p1 ==> "'{0}'" p1{a}
       *   test.t5, p1 ==> "'{0}'" {1}
       *   test.t6, p1 ==> a {1} b p1 c
       *   test.t6, p1, p2 ==> a p2 b p1 c
       *   test.t6, p1, p2, p3 ==> a p2 b p1 c
       *   test.t7 ==> a quoted \ s tringy     x
       */
  
      var i;
      if (typeof(value) == 'string') {
        // Handle escape characters. Done separately from the tokenizing loop below because escape characters are
        // active in quoted strings.
        i = 0;
        while ((i = value.indexOf('\\', i)) != -1) {
          if (value.charAt(i + 1) == 't')
            value = value.substring(0, i) + '\t' + value.substring((i++) + 2); // tab
          else if (value.charAt(i + 1) == 'r')
            value = value.substring(0, i) + '\r' + value.substring((i++) + 2); // return
          else if (value.charAt(i + 1) == 'n')
            value = value.substring(0, i) + '\n' + value.substring((i++) + 2); // line feed
          else if (value.charAt(i + 1) == 'f')
            value = value.substring(0, i) + '\f' + value.substring((i++) + 2); // form feed
          else if (value.charAt(i + 1) == '\\')
            value = value.substring(0, i) + '\\' + value.substring((i++) + 2); // \
          else
            value = value.substring(0, i) + value.substring(i + 1); // Quietly drop the character
        }
  
        // Lazily convert the string to a list of tokens.
        var arr = [], j, index;
        i = 0;
        while (i < value.length) {
          if (value.charAt(i) == '\'') {
            // Handle quotes
            if (i == value.length - 1)
              value = value.substring(0, i); // Silently drop the trailing quote
            else if (value.charAt(i + 1) == '\'')
              value = value.substring(0, i) + value.substring(++i); // Escaped quote
            else {
              // Quoted string
              j = i + 2;
              while ((j = value.indexOf('\'', j)) != -1) {
                if (j == value.length - 1 || value.charAt(j + 1) != '\'') {
                  // Found start and end quotes. Remove them
                  value = value.substring(0, i) + value.substring(i + 1, j) + value.substring(j + 1);
                  i = j - 1;
                  break;
                }
                else {
                  // Found a double quote, reduce to a single quote.
                  value = value.substring(0, j) + value.substring(++j);
                }
              }
  
              if (j == -1) {
                // There is no end quote. Drop the start quote
                value = value.substring(0, i) + value.substring(i + 1);
              }
            }
          }
          else if (value.charAt(i) == '{') {
            // Beginning of an unquoted place holder.
            j = value.indexOf('}', i + 1);
            if (j == -1)
              i++; // No end. Process the rest of the line. Java would throw an exception
            else {
              // Add 1 to the index so that it aligns with the function arguments.
              index = parseInt(value.substring(i + 1, j));
              if (!isNaN(index) && index >= 0) {
                // Put the line thus far (if it isn't empty) into the array
                var s = value.substring(0, i);
                if (s != "")
                  arr.push(s);
                // Put the parameter reference into the array
                arr.push(index);
                // Start the processing over again starting from the rest of the line.
                i = 0;
                value = value.substring(j + 1);
              }
              else
                i = j + 1; // Invalid parameter. Leave as is.
            }
          }
          else
            i++;
        }
  
        // Put the remainder of the no-empty line into the array.
        if (value != "")
          arr.push(value);
        value = arr;
  
        // Make the array the value for the entry.
        $.i18n.map[key] = arr;
      }
  
      if (value.length == 0)
        return "";
      if (value.lengh == 1 && typeof(value[0]) == "string")
        return value[0];
  
      var s = "";
      for (i = 0; i < value.length; i++) {
        if (typeof(value[i]) == "string")
          s += value[i];
        // Must be a number
        else if (phvList && value[i] < phvList.length)
          s += phvList[value[i]];
        else if (!phvList && value[i] + 1 < arguments.length)
          s += arguments[value[i] + 1];
        else
          s += "{" + value[i] + "}";
      }
  
      return s;
    };
  
    /** Language reported by browser, normalized code */
    $.i18n.browserLang = function () {
      return normaliseLanguageCode(navigator.language /* Mozilla */ || navigator.userLanguage /* IE */);
    };
  
  
    /** Load and parse .properties files */
    function loadAndParseFile(filename, settings) {
      $.ajax({
        url: filename,
        async: false,
        cache: settings.cache,
        contentType: 'text/plain;charset=' + settings.encoding,
        dataType: 'text',
        success: function (data, status) {
          parseData(data, settings.mode);
        }
      });
    }
  
    /** Parse .properties files */
    function parseData(data, mode) {
      var parsed = '';
      var parameters = data.split(/\n/);
      var regPlaceHolder = /(\{\d+\})/g;
      var regRepPlaceHolder = /\{(\d+)\}/g;
      var unicodeRE = /(\\u.{4})/ig;
      for (var i = 0; i < parameters.length; i++) {
        parameters[i] = parameters[i].replace(/^\s\s*/, '').replace(/\s\s*$/, ''); // trim
        if (parameters[i].length > 0 && parameters[i].match("^#") != "#") { // skip comments
          var pair = parameters[i].split('=');
          if (pair.length > 0) {
            /** Process key & value */
            var name = unescape(pair[0]).replace(/^\s\s*/, '').replace(/\s\s*$/, ''); // trim
            var value = pair.length == 1 ? "" : pair[1];
            // process multi-line values
            while (value.match(/\\$/) == "\\") {
              value = value.substring(0, value.length - 1);
              value += parameters[++i].replace(/\s\s*$/, ''); // right trim
            }
            // Put values with embedded '='s back together
            for (var s = 2; s < pair.length; s++) {
              value += '=' + pair[s];
            }
            value = value.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); // trim
  
            /** Mode: bundle keys in a map */
            if (mode == 'map' || mode == 'both') {
              // handle unicode chars possibly left out
              var unicodeMatches = value.match(unicodeRE);
              if (unicodeMatches) {
                for (var u = 0; u < unicodeMatches.length; u++) {
                  value = value.replace(unicodeMatches[u], unescapeUnicode(unicodeMatches[u]));
                }
              }
              // add to map
              $.i18n.map[name] = value;
            }
  
            /** Mode: bundle keys as vars/functions */
            if (mode == 'vars' || mode == 'both') {
              value = value.replace(/"/g, '\\"'); // escape quotation mark (")
  
              // make sure namespaced key exists (eg, 'some.key')
              checkKeyNamespace(name);
  
              // value with variable substitutions
              if (regPlaceHolder.test(value)) {
                var parts = value.split(regPlaceHolder);
                // process function args
                var first = true;
                var fnArgs = '';
                var usedArgs = [];
                for (var p = 0; p < parts.length; p++) {
                  if (regPlaceHolder.test(parts[p]) && (usedArgs.length == 0 || usedArgs.indexOf(parts[p]) == -1)) {
                    if (!first) {
                      fnArgs += ',';
                    }
                    fnArgs += parts[p].replace(regRepPlaceHolder, 'v$1');
                    usedArgs.push(parts[p]);
                    first = false;
                  }
                }
                parsed += name + '=function(' + fnArgs + '){';
                // process function body
                var fnExpr = '"' + value.replace(regRepPlaceHolder, '"+v$1+"') + '"';
                parsed += 'return ' + fnExpr + ';' + '};';
  
                // simple value
              } else {
                parsed += name + '="' + value + '";';
              }
            } // END: Mode: bundle keys as vars/functions
          } // END: if(pair.length > 0)
        } // END: skip comments
      }
      eval(parsed);
    }
  
    /** Make sure namespace exists (for keys with dots in name) */
  // TODO key parts that start with numbers quietly fail. i.e. month.short.1=Jan
    function checkKeyNamespace(key) {
      var regDot = /\./;
      if (regDot.test(key)) {
        var fullname = '';
        var names = key.split(/\./);
        for (var i = 0; i < names.length; i++) {
          if (i > 0) {
            fullname += '.';
          }
          fullname += names[i];
          if (eval('typeof ' + fullname + ' == "undefined"')) {
            eval(fullname + '={};');
          }
        }
      }
    }
  
    /** Make sure filename is an array */
    function getFiles(names) {
      return (names && names.constructor == Array) ? names : [names];
    }
  
    /** Ensure language code is in the format aa_AA. */
    function normaliseLanguageCode(lang) {
      lang = lang.toLowerCase();
      if (lang.length > 3) {
        lang = lang.substring(0, 3) + lang.substring(3).toUpperCase();
      }
      return lang;
    }
  
    /** Unescape unicode chars ('\u00e3') */
    function unescapeUnicode(str) {
      // unescape unicode codes
      var codes = [];
      var code = parseInt(str.substr(2), 16);
      if (code >= 0 && code < Math.pow(2, 16)) {
        codes.push(code);
      }
      // convert codes to text
      var unescaped = '';
      for (var i = 0; i < codes.length; ++i) {
        unescaped += String.fromCharCode(codes[i]);
      }
      return unescaped;
    }
  
    /* Cross-Browser Split 1.0.1
     (c) Steven Levithan <stevenlevithan.com>; MIT License
     An ECMA-compliant, uniform cross-browser split method */
    var cbSplit;
  // avoid running twice, which would break `cbSplit._nativeSplit`'s reference to the native `split`
    if (!cbSplit) {
      cbSplit = function (str, separator, limit) {
        // if `separator` is not a regex, use the native `split`
        if (Object.prototype.toString.call(separator) !== "[object RegExp]") {
          if (typeof cbSplit._nativeSplit == "undefined")
            return str.split(separator, limit);
          else
            return cbSplit._nativeSplit.call(str, separator, limit);
        }
  
        var output = [],
            lastLastIndex = 0,
            flags = (separator.ignoreCase ? "i" : "") +
                (separator.multiline ? "m" : "") +
                (separator.sticky ? "y" : ""),
            separator = RegExp(separator.source, flags + "g"), // make `global` and avoid `lastIndex` issues by working with a copy
            separator2, match, lastIndex, lastLength;
  
        str = str + ""; // type conversion
        if (!cbSplit._compliantExecNpcg) {
          separator2 = RegExp("^" + separator.source + "$(?!\\s)", flags); // doesn't need /g or /y, but they don't hurt
        }
  
        /* behavior for `limit`: if it's...
         - `undefined`: no limit.
         - `NaN` or zero: return an empty array.
         - a positive number: use `Math.floor(limit)`.
         - a negative number: no limit.
         - other: type-convert, then use the above rules. */
        if (limit === undefined || +limit < 0) {
          limit = Infinity;
        } else {
          limit = Math.floor(+limit);
          if (!limit) {
            return [];
          }
        }
  
        while (match = separator.exec(str)) {
          lastIndex = match.index + match[0].length; // `separator.lastIndex` is not reliable cross-browser
  
          if (lastIndex > lastLastIndex) {
            output.push(str.slice(lastLastIndex, match.index));
  
            // fix browsers whose `exec` methods don't consistently return `undefined` for nonparticipating capturing groups
            if (!cbSplit._compliantExecNpcg && match.length > 1) {
              match[0].replace(separator2, function () {
                for (var i = 1; i < arguments.length - 2; i++) {
                  if (arguments[i] === undefined) {
                    match[i] = undefined;
                  }
                }
              });
            }
  
            if (match.length > 1 && match.index < str.length) {
              Array.prototype.push.apply(output, match.slice(1));
            }
  
            lastLength = match[0].length;
            lastLastIndex = lastIndex;
  
            if (output.length >= limit) {
              break;
            }
          }
  
          if (separator.lastIndex === match.index) {
            separator.lastIndex++; // avoid an infinite loop
          }
        }
  
        if (lastLastIndex === str.length) {
          if (lastLength || !separator.test("")) {
            output.push("");
          }
        } else {
          output.push(str.slice(lastLastIndex));
        }
  
        return output.length > limit ? output.slice(0, limit) : output;
      };
  
      cbSplit._compliantExecNpcg = /()??/.exec("")[1] === undefined; // NPCG: nonparticipating capturing group
      cbSplit._nativeSplit = String.prototype.split;
  
    } // end `if (!cbSplit)`
    String.prototype.split = function (separator, limit) {
      return cbSplit(this, separator, limit);
    };
  
  })(jQuery);