docs: function(userAgentWrapper) {
              var output = {};
  
              ////////////////////////////////////////////////////////////////////
              // Initialization
              ////////////////////////////////////////////////////////////////////
  
              var uaInfo = userAgentWrapper.results;
  
              var browser = uaInfo.browser;
              var engine = uaInfo.engine;
              var os = uaInfo.os;
  
              // ---------------------------------------- simply copied properties
  
              output.ua = userAgentWrapper.ua;
  
              // --------------------------------------- for anticipated detection
  
              var version = null;
  
  
  
              ////////////////////////////////////////////////////////////////////
              // OS
              ////////////////////////////////////////////////////////////////////
  
              // --------------------------------------------------------- version
  
              var osVersion = os.version;
  
              if (osVersion != null) {
                  output.osVersion = osVersion;
              }
  
              // ------------------------------------------------------------ name
  
              var osName = os.name;
  
              if (osName == null) {
                  osName = "";
              }
  
              switch (UserAgent.normalizeName(osName)) {
                  case "windows":
                      if (osVersion == " M") {
                          // user agents with "Windows Mobile" instead of "Windows Phone" not properly recognized.
                          this._setFlag(output, "WindowsPhone");
                          if (/(Windows Mobile; WCE;)/ig.test(output.ua)) {
                              output.osVersion = "WCE";
                          } else {
                              output.osVersion = "";
                          }
                      } else {
                          this._setFlag(output, "Windows");
                          /* BACKWARD-COMPATIBILITY-BEGIN (GitHub #1397) */
                          output._environment = "Windows";
                          /* BACKWARD-COMPATIBILITY-END (GitHub #1397) */
                      }
                      break;
  
                  case "macos":
                      this._setFlag(output, "Mac");
                      /* BACKWARD-COMPATIBILITY-BEGIN (GitHub #1397) */
                      output._environment = "MacOS";
                      /* BACKWARD-COMPATIBILITY-END (GitHub #1397) */
                      break;
  
                  case 'ios':
                      this._setFlag(output, "IOS");
                      break;
  
                  case 'windowsphoneos':
                      this._setFlag(output, "WindowsPhone");
                      break;
  
                  default:
                      if (ariaUtilsArray.contains(["Android", "BlackBerry", "Symbian"], osName)) {
                          this._setFlag(output, osName);
                      } else {
                          this._setFlag(output, "OtherOS");
                      }
              }
  
              output.osName = osName;
  
  
  
              ////////////////////////////////////////////////////////////////////
              // Browser
              ////////////////////////////////////////////////////////////////////
  
              // ------------------------------------------------------------ name
  
              var name = browser.name;
  
              var maybeOtherBrowser = false;
  
              if (name != null) {
                  switch (UserAgent.normalizeName(name)) {
                      case "mobilesafari":
                          if (output.isAndroid) {
                              this._setFlag(output, "AndroidBrowser");
                          } else if (output.isBlackBerry) {
                              this._setFlag(output, "BlackBerryBrowser");
                          } else {
                              this._setFlag(output, "SafariMobile");
                              this._setFlag(output, "Safari");
                          }
                          break;
                      case "operamini":
                          this._setFlag(output, "OperaMini");
                          this._setFlag(output, "Opera");
                          break;
                      case "operamobi":
                          this._setFlag(output, "OperaMobile");
                          this._setFlag(output, "Opera");
                          break;
                      case "safari":
                          if (output.isSymbian) {
                              this._setFlag(output, "S60");
                          } else {
                              this._setFlag(output, "Safari");
                          }
                          break;
                      case "androidbrowser":
                          this._setFlag(output, "AndroidBrowser");
                          break;
                      case "iemobile":
                          this._setFlag(output, "IEMobile");
                          this._setFlag(output, "IE");
                          break;
                      default:
                          maybeOtherBrowser = true;
                  }
  
                  if (ariaUtilsArray.contains(["Firefox", "Chrome", "IE", "Opera", "Edge", "PhantomJS"], name)) {
                      this._setFlag(output, name);
                      maybeOtherBrowser = false;
                  }
              } else {
                  if (output.isBlackBerry) {
                      this._setFlag(output, "BlackBerryBrowser");
                      name = "BlackBerry";
                  }
              }
  
              if (maybeOtherBrowser) {
                  this._setFlag(output, "OtherBrowser");
              }
  
              // Special case - NGBrowser
              var match = /BrowserNG\/(\d+(?:\.\d+)*)/ig.exec(output.ua);
              if (match != null) {
                  name = "NokiaBrowser";
                  version = match[1];
              }
  
              output.name = name;
  
              // --------------------------------------- major version (detection)
  
              var detectedMajorVersion = null;
  
              if (output.isIE) {
                  // PTR 05207453
                  // With compatibility view, it can become tricky to
                  // detect the version.
                  // What is important to detect here is the document mode
                  // (which defines how the browser really
                  // reacts), NOT the browser mode (how the browser says
                  // it reacts, through conditional comments
                  // and ua string).
                  //
                  // In IE7 document.documentMode is undefined. For IE8+
                  // (also in document modes emulating IE7) it is defined
                  // and readonly.
                  /* BACKWARD-COMPATIBILITY-BEGIN (GitHub #1397) */
                  if (browser.major != "6") {
                  /* BACKWARD-COMPATIBILITY-END (GitHub #1397) */
                  var document = Aria.$frameworkWindow.document;
                  detectedMajorVersion = document.documentMode || 7;
                  detectedMajorVersion = +detectedMajorVersion;
                  /* BACKWARD-COMPATIBILITY-BEGIN (GitHub #1397) */
                  }
                  /* BACKWARD-COMPATIBILITY-END (GitHub #1397) */
              }
  
              // ---------------------------------------------------- full version
  
              if (version == null) {
                  version = browser.version;
              }
  
              if (detectedMajorVersion != null) {
                  // the browser is not what it claims to be!
                  // make sure output.version is consistent with detected
                  // major version
                  version = "" + detectedMajorVersion + ".0";
              }
  
              // ----------------------------------------------- major version (2)
  
              var majorVersion;
  
              if (detectedMajorVersion != null) {
                  majorVersion = detectedMajorVersion;
              } else if (version != null) {
                  var part = /^(\d+)*/.exec(version);
                  if (part != null) {
                      majorVersion = part[1];
                  }
              } else if (browser.major != null) {
                  majorVersion = browser.major;
              }
  
              if (majorVersion != null) {
                  majorVersion = +majorVersion;
                  output.majorVersion = majorVersion;
              }
  
              // -------------------------------------------------------- name (2)
  
              if (output.isIE) {
                  if (majorVersion != null) {
                      this._setFlag(output, "IE" + majorVersion);
  
                      /* BACKWARD-COMPATIBILITY-BEGIN (GitHub #1397) */
                      if (majorVersion == 6) {
                          output._isIE6 = true;
                          this._setFlag(output, "OldIE");
                      }
                      /* BACKWARD-COMPATIBILITY-END (GitHub #1397) */
                      if (majorVersion >= 7) {
                          if (majorVersion <= 10) {
                              this._setFlag(output, "OldIE");
                          } else {
                              this._setFlag(output, "ModernIE");
                          }
                      }
                  }
              }
  
              // ------------------------------------------------ full version (2)
  
              if (version == null && majorVersion != null) {
                  version = "" + majorVersion;
              }
  
              if (version != null) {
                  output.version = version;
              }
  
  
  
              ////////////////////////////////////////////////////////////////////
              // Rendering engine
              ////////////////////////////////////////////////////////////////////
  
              // ------------------------------------------------------------ name
  
              var engineName = engine.name;
  
              if (engineName != null) {
                  switch (UserAgent.normalizeName(engineName)) {
                      case 'webkit':
                          this._setFlag(output, "Webkit");
                          break;
  
                      case 'gecko':
                          this._setFlag(output, "Gecko");
                          break;
                  }
              }
  
  
  
              ////////////////////////////////////////////////////////////////////
              // Mobile browser specific properties
              ////////////////////////////////////////////////////////////////////
  
              if (output.isIEMobile) {
                  var fullMatch = /(iemobile)[\/\s]?((\d+)?[\w\.]*)/ig.exec(output.ua);
  
                  if (fullMatch != null) {
                      var match = fullMatch[0];
  
                      if (match != null && ariaUtilsArray.contains(['xblwp7', 'zunewp7'], match.toLowerCase())) {
                          this._setFlag(output, "DesktopView");
                      } else {
                          this._setFlag(output, "MobileView");
                      }
                  }
              }
  
  
  
              /* BACKWARD-COMPATIBILITY-BEGIN (GitHub #1397) */
  
              ////////////////////////////////////////////////////////////////////
              // Device detection
              //
              // Copied (and adapted) from aria.utils.Device
              ////////////////////////////////////////////////////////////////////
  
              var device = uaInfo.device;
              var deviceType = device.type;
              var result;
  
              // -------------------------------------------------------- isTablet
  
              result = false;
  
              if (!result) {
                  if (deviceType != null) {
                      result = UserAgent.normalizeName(deviceType) == "tablet";
                  }
              }
              if (!result) {
                  result = /(iPad|SCH-I800|GT-P1000|GT-P1000R|GT-P1000M|SGH-T849|SHW-M180S|android 3.0|xoom|NOOK|playbook|tablet|silk|kindle|GT-P7510)/i.test(output.ua);
              }
  
              if (result) {
                  output._isTablet = true;
              }
  
              // --------------------------------------------------------- isPhone
  
              result = false;
  
              if (!result) {
                  if (deviceType != null) {
                      result = UserAgent.normalizeName(deviceType) == "mobile";
                  }
              }
              if (!result) {
                  if (!output._isTablet) {
                      result = output.isAndroid
                      || output.isBlackBerry
                      || output.isIOS
                      || output.isSymbian
                      || output.isWindowsPhone
                      || UserAgent.normalizeName(output.osName) == "webos"
                      ;
                  }
              }
  
              if (result) {
                  output._isPhone = true;
              }
  
              // ------------------------------------------------------ deviceName
  
              var parts = [
                  device.vendor,
                  device.model
              ];
  
              for (var index = parts.length - 1; index >= 0; index--) {
                  var part = parts[index];
                  if (part == null || part.length == null || part.length <= 0) {
                      parts.splice(index, 1);
                  }
              }
  
              var deviceName = parts.join(" - ");
  
              output._deviceName = deviceName;
              /* BACKWARD-COMPATIBILITY-END (GitHub #1397) */
  
              ////////////////////////////////////////////////////////////////////
              // Output
              ////////////////////////////////////////////////////////////////////
  
              return output;
          }