docs: function (evt) {
              var domEventCopy = (evt.$DomEvent != null);
              // objCopy = true happens when creating a DomEventWrapper from a DomEvent object
  
              // initialize the object property - cf. eventMap
              if (!domEventCopy && isIE8orLess && Aria.$window.event) {
  
                  evt = Aria.$window.event;
                  // create all object properties from the map
                  for (var k in eventMap) {
                      if (eventMap.hasOwnProperty(k)) {
                          this[k] = evt[eventMap[k]];
                      }
                  }
                  if (evt.type == "mouseout") {
                      this.relatedTarget = evt["toElement"];
                  } else if (evt.type == "mouseover") {
                      this.relatedTarget = evt["fromElement"];
                  }
                  // TODO: convert evt.button values (not the same in IE/Safari/FF)
              } else {
                  // W3C event - duplicate event values
                  for (var k in eventMap) {
                      if (eventMap.hasOwnProperty(k)) {
                          this[k] = evt[k];
                      }
                  }
              }
  
              this.type = getType(evt.type);
              // TODO keyCode / charCode should be homogenized between IE and other browsers
              // What must be implemented: (cf. http://www.quirksmode.org/js/keys.html)
              // keyCode=keyboard key code (e.g. 'A' and 'a' have the same key code: 65)
              // charCode=ASCII value of the resulting character (i.e. 'A'=65 'a'=97
              this.charCode = 0;
              this.keyCode = 0;
              if (this.type == 'keydown' || this.type == 'keyup') {
                  this.keyCode = evt.keyCode;
                  this.isSpecialKey = this.isSpecialKey(this.keyCode, evt);
              } else if (this.type == 'keypress') {
                  // In case of a keypress event the "keycode"
                  // is different from the keyup or keydown situation
                  // We use keyCode OR charCode to calculate it
                  var baseKeyCode = evt.keyCode || evt.charCode;
  
                  /*
                   * We need to calculate the corresponding keycode ... On gecko browsers, charcode is usually used and
                   * has the same value as the non-gecko keycode version For special keys such as TAB, ENTER, DELETE,
                   * BACKSPACE, ARROWS, function keys ... the evt.keycode is valid, should be used, without any offset
                   * applied. So if evt.keyCode is defined on gecko browsers we have to skip applying an offset to the
                   * keycode
                   */
                  var skipOffset = isGeckoBefore66 && evt.keyCode;
                  this.keyCode = baseKeyCode;
  
                  if (!skipOffset) {
  
                      // default
                      this.keyCode = baseKeyCode;
  
                      // before 32 > strange chars
                      // 32 > space, stays the same
                      if (baseKeyCode > 32 && baseKeyCode < 38) {
                          this.keyCode = baseKeyCode + 16;
                      }
                      if (baseKeyCode == 38) {
                          this.keyCode = 55;
                      }
                      if (baseKeyCode == 40) {
                          this.keyCode = 57;
                      }
                      /*
                      *  if (baseKeyCode == 39) { this.keyCode = 56; } if (baseKeyCode == 41) { this.keyCode = 48; }
                      */
                      if (baseKeyCode > 41 && baseKeyCode < 48) {
                          // / to * range
                          this.keyCode = baseKeyCode + 64;
                      }
                      if (baseKeyCode > 47 && baseKeyCode < 58) {
                          // 0 to 9 range
                          this.keyCode = baseKeyCode + 48;
                      } /*
                      * if (baseKeyCode == 58) { this.keyCode = 59; } // 59 > 59 if (baseKeyCode == 60) {
                      * this.keyCode = 188; } if (baseKeyCode == 61) { this.keyCode = 107; } if (baseKeyCode == 62) {
                      * this.keyCode = 190; } if (baseKeyCode == 62) { this.keyCode = 191; } if (baseKeyCode == 64) {
                      * this.keyCode = 50; }
                      */
                      // 65 -> 90 A - Z
  
                      if (baseKeyCode > 96 && baseKeyCode < 123) {
                          // 'a' to 'z' range - transform to 65-90 range
                          this.keyCode = baseKeyCode - 32;
                      }
                  }
                  this.charCode = baseKeyCode;
  
                  this.isSpecialKey = this.isSpecialKey(this.keyCode, evt);
              }
  
              /**
               * Stop propagation for this event. Should not be modified directly (use the stopPropagation method).
               * @type Boolean
               */
              this.hasStopPropagation = false;
  
              /**
               * Prevent default for this event. Should not be modified directly (use the preventDefault method).
               * @type Boolean
               */
              this.hasPreventDefault = false;
  
              /**
               * Cancel any default action associated with the event
               * @param {Boolean} stopPropagation tells if event propagation must also be stopped - default: false
               * @method
               */
              this.preventDefault = !evt.preventDefault ? function (stopPropagation) {
                  this.hasPreventDefault = true;
                  evt.returnValue = false;
                  if (stopPropagation === true) {
                      this.stopPropagation();
                  }
              } : function (stopPropagation) {
                  this.hasPreventDefault = true;
                  evt.preventDefault();
                  if (stopPropagation === true) {
                      this.stopPropagation();
                  }
              };
  
              /**
               * Prevent the event from bubbling
               * @method
               */
              this.stopPropagation = !evt.stopPropagation ? function () {
                  this.hasStopPropagation = true;
                  evt.cancelBubble = true;
              } : function () {
                  this.hasStopPropagation = true;
                  evt.stopPropagation();
              };
  
              /**
               * Needs to be here in order to access the closure variable 'evt'
               * @private
               */
              this._dispose = function () {
                  evt = null;
                  this.preventDefault = null;
                  this.stopPropagation = null;
              };
  
          }