text: /**
   * @license RequireJS text 2.0.13+ Copyright (c) 2010-2014, The Dojo Foundation All Rights Reserved.
   * Available via the MIT or new BSD license.
   * see: http://github.com/requirejs/text for details
   */
  /*jslint regexp: true */
  /*global require, XMLHttpRequest, ActiveXObject,
    define, window, process, Packages,
    java, location, Components, FileUtils */
  
  define(['module'], function (module) {
      'use strict';
  
      var text, fs, Cc, Ci, xpcIsWindows,
          progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'],
          xmlRegExp = /^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im,
          bodyRegExp = /<body[^>]*>\s*([\s\S]+)\s*<\/body>/im,
          hasLocation = typeof location !== 'undefined' && location.href,
          defaultProtocol = hasLocation && location.protocol && location.protocol.replace(/\:/, ''),
          defaultHostName = hasLocation && location.hostname,
          defaultPort = hasLocation && (location.port || undefined),
          buildMap = {},
          masterConfig = (module.config && module.config()) || {};
  
      text = {
          version: '2.0.13+',
  
          strip: function (content) {
              //Strips <?xml ...?> declarations so that external SVG and XML
              //documents can be added to a document without worry. Also, if the string
              //is an HTML document, only the part inside the body tag is returned.
              if (content) {
                  content = content.replace(xmlRegExp, "");
                  var matches = content.match(bodyRegExp);
                  if (matches) {
                      content = matches[1];
                  }
              } else {
                  content = "";
              }
              return content;
          },
  
          jsEscape: function (content) {
              return content.replace(/(['\\])/g, '\\$1')
                  .replace(/[\f]/g, "\\f")
                  .replace(/[\b]/g, "\\b")
                  .replace(/[\n]/g, "\\n")
                  .replace(/[\t]/g, "\\t")
                  .replace(/[\r]/g, "\\r")
                  .replace(/[\u2028]/g, "\\u2028")
                  .replace(/[\u2029]/g, "\\u2029");
          },
  
          createXhr: masterConfig.createXhr || function () {
              //Would love to dump the ActiveX crap in here. Need IE 6 to die first.
              var xhr, i, progId;
              if (typeof XMLHttpRequest !== "undefined") {
                  return new XMLHttpRequest();
              } else if (typeof ActiveXObject !== "undefined") {
                  for (i = 0; i < 3; i += 1) {
                      progId = progIds[i];
                      try {
                          xhr = new ActiveXObject(progId);
                      } catch (e) {}
  
                      if (xhr) {
                          progIds = [progId];  // so faster next time
                          break;
                      }
                  }
              }
  
              return xhr;
          },
  
          /**
           * Parses a resource name into its component parts. Resource names
           * look like: module/name.ext!strip, where the !strip part is
           * optional.
           * @param {String} name the resource name
           * @returns {Object} with properties "moduleName", "ext" and "strip"
           * where strip is a boolean.
           */
          parseName: function (name) {
              var modName, ext, temp,
                  strip = false,
                  index = name.lastIndexOf("."),
                  isRelative = name.indexOf('./') === 0 ||
                               name.indexOf('../') === 0;
  
              if (index !== -1 && (!isRelative || index > 1)) {
                  modName = name.substring(0, index);
                  ext = name.substring(index + 1);
              } else {
                  modName = name;
              }
  
              temp = ext || modName;
              index = temp.indexOf("!");
              if (index !== -1) {
                  //Pull off the strip arg.
                  strip = temp.substring(index + 1) === "strip";
                  temp = temp.substring(0, index);
                  if (ext) {
                      ext = temp;
                  } else {
                      modName = temp;
                  }
              }
  
              return {
                  moduleName: modName,
                  ext: ext,
                  strip: strip
              };
          },
  
          xdRegExp: /^((\w+)\:)?\/\/([^\/\\]+)/,
  
          /**
           * Is an URL on another domain. Only works for browser use, returns
           * false in non-browser environments. Only used to know if an
           * optimized .js version of a text resource should be loaded
           * instead.
           * @param {String} url
           * @returns Boolean
           */
          useXhr: function (url, protocol, hostname, port) {
              var uProtocol, uHostName, uPort,
                  match = text.xdRegExp.exec(url);
              if (!match) {
                  return true;
              }
              uProtocol = match[2];
              uHostName = match[3];
  
              uHostName = uHostName.split(':');
              uPort = uHostName[1];
              uHostName = uHostName[0];
  
              return (!uProtocol || uProtocol === protocol) &&
                     (!uHostName || uHostName.toLowerCase() === hostname.toLowerCase()) &&
                     ((!uPort && !uHostName) || uPort === port);
          },
  
          finishLoad: function (name, strip, content, onLoad) {
              content = strip ? text.strip(content) : content;
              if (masterConfig.isBuild) {
                  buildMap[name] = content;
              }
              onLoad(content);
          },
  
          load: function (name, req, onLoad, config) {
              //Name has format: some.module.filext!strip
              //The strip part is optional.
              //if strip is present, then that means only get the string contents
              //inside a body tag in an HTML string. For XML/SVG content it means
              //removing the <?xml ...?> declarations so the content can be inserted
              //into the current doc without problems.
  
              // Do not bother with the work if a build and text will
              // not be inlined.
              if (config && config.isBuild && !config.inlineText) {
                  onLoad();
                  return;
              }
  
              masterConfig.isBuild = config && config.isBuild;
  
              var parsed = text.parseName(name),
                  nonStripName = parsed.moduleName +
                      (parsed.ext ? '.' + parsed.ext : ''),
                  url = req.toUrl(nonStripName),
                  useXhr = (masterConfig.useXhr) ||
                           text.useXhr;
  
              // Do not load if it is an empty: url
              if (url.indexOf('empty:') === 0) {
                  onLoad();
                  return;
              }
  
              //Load the text. Use XHR if possible and in a browser.
              if (!hasLocation || useXhr(url, defaultProtocol, defaultHostName, defaultPort)) {
                  text.get(url, function (content) {
                      text.finishLoad(name, parsed.strip, content, onLoad);
                  }, function (err) {
                      if (onLoad.error) {
                          onLoad.error(err);
                      }
                  });
              } else {
                  //Need to fetch the resource across domains. Assume
                  //the resource has been optimized into a JS module. Fetch
                  //by the module name + extension, but do not include the
                  //!strip part to avoid file system issues.
                  req([nonStripName], function (content) {
                      text.finishLoad(parsed.moduleName + '.' + parsed.ext,
                                      parsed.strip, content, onLoad);
                  });
              }
          },
  
          write: function (pluginName, moduleName, write, config) {
              if (buildMap.hasOwnProperty(moduleName)) {
                  var content = text.jsEscape(buildMap[moduleName]);
                  write.asModule(pluginName + "!" + moduleName,
                                 "define(function () { return '" +
                                     content +
                                 "';});\n");
              }
          },
  
          writeFile: function (pluginName, moduleName, req, write, config) {
              var parsed = text.parseName(moduleName),
                  extPart = parsed.ext ? '.' + parsed.ext : '',
                  nonStripName = parsed.moduleName + extPart,
                  //Use a '.js' file name so that it indicates it is a
                  //script that can be loaded across domains.
                  fileName = req.toUrl(parsed.moduleName + extPart) + '.js';
  
              //Leverage own load() method to load plugin value, but only
              //write out values that do not have the strip argument,
              //to avoid any potential issues with ! in file names.
              text.load(nonStripName, req, function (value) {
                  //Use own write() method to construct full module value.
                  //But need to create shell that translates writeFile's
                  //write() to the right interface.
                  var textWrite = function (contents) {
                      return write(fileName, contents);
                  };
                  textWrite.asModule = function (moduleName, contents) {
                      return write.asModule(moduleName, fileName, contents);
                  };
  
                  text.write(pluginName, nonStripName, textWrite, config);
              }, config);
          }
      };
  
      if (masterConfig.env === 'node' || (!masterConfig.env &&
              typeof process !== "undefined" &&
              process.versions &&
              !!process.versions.node &&
              !process.versions['node-webkit'] &&
              !process.versions['atom-shell'])) {
          //Using special require.nodeRequire, something added by r.js.
          fs = require.nodeRequire('fs');
  
          text.get = function (url, callback, errback) {
              try {
                  var file = fs.readFileSync(url, 'utf8');
                  //Remove BOM (Byte Mark Order) from utf8 files if it is there.
                  if (file[0] === '\uFEFF') {
                      file = file.substring(1);
                  }
                  callback(file);
              } catch (e) {
                  if (errback) {
                      errback(e);
                  }
              }
          };
      } else if (masterConfig.env === 'xhr' || (!masterConfig.env &&
              text.createXhr())) {
          text.get = function (url, callback, errback, headers) {
              var xhr = text.createXhr(), header;
              xhr.open('GET', url, true);
  
              //Allow plugins direct access to xhr headers
              if (headers) {
                  for (header in headers) {
                      if (headers.hasOwnProperty(header)) {
                          xhr.setRequestHeader(header.toLowerCase(), headers[header]);
                      }
                  }
              }
  
              //Allow overrides specified in config
              if (masterConfig.onXhr) {
                  masterConfig.onXhr(xhr, url);
              }
  
              xhr.onreadystatechange = function (evt) {
                  var status, err;
                  //Do not explicitly handle errors, those should be
                  //visible via console output in the browser.
                  if (xhr.readyState === 4) {
                      status = xhr.status || 0;
                      if (status > 399 && status < 600) {
                          //An http 4xx or 5xx error. Signal an error.
                          err = new Error(url + ' HTTP status: ' + status);
                          err.xhr = xhr;
                          if (errback) {
                              errback(err);
                          }
                      } else {
                          callback(xhr.responseText);
                      }
  
                      if (masterConfig.onXhrComplete) {
                          masterConfig.onXhrComplete(xhr, url);
                      }
                  }
              };
              xhr.send(null);
          };
      } else if (masterConfig.env === 'rhino' || (!masterConfig.env &&
              typeof Packages !== 'undefined' && typeof java !== 'undefined')) {
          //Why Java, why is this so awkward?
          text.get = function (url, callback) {
              var stringBuffer, line,
                  encoding = "utf-8",
                  file = new java.io.File(url),
                  lineSeparator = java.lang.System.getProperty("line.separator"),
                  input = new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(file), encoding)),
                  content = '';
              try {
                  stringBuffer = new java.lang.StringBuffer();
                  line = input.readLine();
  
                  // Byte Order Mark (BOM) - The Unicode Standard, version 3.0, page 324
                  // http://www.unicode.org/faq/utf_bom.html
  
                  // Note that when we use utf-8, the BOM should appear as "EF BB BF", but it doesn't due to this bug in the JDK:
                  // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4508058
                  if (line && line.length() && line.charAt(0) === 0xfeff) {
                      // Eat the BOM, since we've already found the encoding on this file,
                      // and we plan to concatenating this buffer with others; the BOM should
                      // only appear at the top of a file.
                      line = line.substring(1);
                  }
  
                  if (line !== null) {
                      stringBuffer.append(line);
                  }
  
                  while ((line = input.readLine()) !== null) {
                      stringBuffer.append(lineSeparator);
                      stringBuffer.append(line);
                  }
                  //Make sure we return a JavaScript string and not a Java string.
                  content = String(stringBuffer.toString()); //String
              } finally {
                  input.close();
              }
              callback(content);
          };
      } else if (masterConfig.env === 'xpconnect' || (!masterConfig.env &&
              typeof Components !== 'undefined' && Components.classes &&
              Components.interfaces)) {
          //Avert your gaze!
          Cc = Components.classes;
          Ci = Components.interfaces;
          Components.utils['import']('resource://gre/modules/FileUtils.jsm');
          xpcIsWindows = ('@mozilla.org/windows-registry-key;1' in Cc);
  
          text.get = function (url, callback) {
              var inStream, convertStream, fileObj,
                  readData = {};
  
              if (xpcIsWindows) {
                  url = url.replace(/\//g, '\\');
              }
  
              fileObj = new FileUtils.File(url);
  
              //XPCOM, you so crazy
              try {
                  inStream = Cc['@mozilla.org/network/file-input-stream;1']
                             .createInstance(Ci.nsIFileInputStream);
                  inStream.init(fileObj, 1, 0, false);
  
                  convertStream = Cc['@mozilla.org/intl/converter-input-stream;1']
                                  .createInstance(Ci.nsIConverterInputStream);
                  convertStream.init(inStream, "utf-8", inStream.available(),
                  Ci.nsIConverterInputStream.DEFAULT_REPLACEMENT_CHARACTER);
  
                  convertStream.readString(inStream.available(), readData);
                  convertStream.close();
                  inStream.close();
                  callback(readData.value);
              } catch (e) {
                  throw new Error((fileObj && fileObj.path || '') + ': ' + e);
              }
          };
      }
      return text;
  });
  