docs: function() {
      	var i18n = {};
  
      	/** Map holding bundle keys (if mode: 'map') */
      	i18n.map = {};
  
      	/**
      	 *
           * @method properties
           * @memberof i18nBase
      	 *
      	 * @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
      	 */
      	this.properties = function(settings) {
      	    // set up settings
      	    var defaults = {
      		    name: Augmented.Configuration.MessageBundle,//'Messages',
      		    language: '',
      		    path: '',
      		    mode: 'vars',
      		    cache: false,
      		    encoding: 'UTF-8',
      		    callback: null
      	    };
      	    settings = Augmented.Utility.extend(defaults, settings);
      	    if (settings.language === null || settings.language === '') {
      		settings.language = browserLang();
      	    }
      	    if (settings.language === null) {
      		settings.language = '';
      	    }
  
      	    // load and parse bundle files
      	    var files = getFiles(settings.name);
              var i = 0, l = files.length;
      	    for (i = 0; i < l; 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, prop('com.company.bundles.menu_add')
         * @method prop
         * @memberof i18nBase
      	 */
      	this.prop = function(key /*
      				     * Add parameters as function arguments as
      				     * necessary
      				     */) {
      	    var value = i18n.map[key];
      	    if (!value) {
      		    return '[' + key + ']';
              }
  
      	    var phvList;
      	    if (arguments.length == 2 && Array.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 = "";
              var l = value.length;
      	    for (i = 0; i < l; 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
         */
      	function browserLang() {
      	    return normaliseLanguageCode(navigator.language /* Mozilla */ || navigator.userLanguage /* IE */);
      	}
  
      	/** Load and parse .properties files
         * @method loadAndParseFile
         * @memberof i18nBase
         * @param filename
         * @param settings
         */
      	function loadAndParseFile(filename, settings) {
      	    Augmented.ajax({
          		url: filename,
          		async: true,
          		cache: settings.cache,
          		contentType: 'text/plain;charset=' + settings.encoding,
          		dataType: 'text',
          		success: function (data, status) {
                      logger.debug("message bundel ajax call - success");
          		    parseData(data, settings.mode);
          		},
                  error: function(data, status) {
  logger.debug("message bundel ajax call - fail " + data);
                  }
      	    });
      	}
  
      	/*
         * 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;
              var i = 0, l = parameters.length;
      	    for (i = 0; i < l; 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);
              /* TODO: refactor */
      	}
  
      	/** 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) {
              try {
          	    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 (typeof fullname === "undefined") {
                              fullname = {};
                          }
  
              		    /*if (eval('typeof ' + fullname + ' == "undefined"')) {
              			    eval(fullname + '={};');
              		    }*/
          		    }
      	        }
              } catch(e) {
                  logger.error("AUGMENTED: MessageBundle " + e);
              }
      	}
  
      	/* 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;
      	}
      }