natives.EventDispatcherClass = function EventDispatcherClass(runtime, scope, instance, baseClass) {
  function constructorHook() {
    this.d = runtime.notifyConstruct(this, Array.prototype.slice.call(arguments, 0));
    return instance.apply(this, arguments);
  }

  var c = new runtime.domain.system.Class("EventDispatcher", constructorHook, Domain.passthroughCallable(constructorHook));
  c.extend(baseClass);

  c.nativeStatics = {};

  c.nativeMethods = {
    // ctor :: target:IEventDispatcher -> void
    ctor: function ctor(target) {
      // Creating proxy listeners to wrap an Event object into native one
      var listeners = new WeakMap();
      this._wrapListener = function (args) {
        var ar = Array.prototype.slice.call(args, 0);
        var obj = this;
        var listener = ar[1];
        var wrapper = listeners.get(listener);
        if (!wrapper) {
          wrapper = function (e) {
            // HACK create script object if one does not exist, using the loader
            var wrappedArg = e.scriptObject ||
              obj.nativeObject.stage._loader._bindNativeObject(e);
            listener(wrappedArg);
          };
          listeners.set(listener, wrapper);
        }
        ar[1] = wrapper;
        return ar;
      };
    },

    // addEventListener :: type:String, listener:Function, useCapture:Boolean=false, priority:int=0, useWeakReference:Boolean=false -> void
    addEventListener: function addEventListener(type, listener, useCapture, priority, useWeakReference) {
      this.nativeObject.addEventListener.apply(this.nativeObject, this._wrapListener(arguments));
    },

    // removeEventListener :: type:String, listener:Function, useCapture:Boolean=false -> void
    removeEventListener: function removeEventListener(type, listener, useCapture) {
      this.nativeObject.removeEventListener.apply(this.nativeObject, this._wrapListener(arguments));
    },

    // hasEventListener :: type:String -> Boolean
    hasEventListener: function hasEventListener(type) {
      notImplemented("EventDispatcher.hasEventListener");
    },

    // willTrigger :: type:String -> Boolean
    willTrigger: function willTrigger(type) {
      notImplemented("EventDispatcher.willTrigger");
    },

    // dispatchEventFunction :: event:Event -> Boolean
    dispatchEventFunction: function dispatchEventFunction(event) {
      notImplemented("EventDispatcher.dispatchEventFunction");
    }
  };

  return c;
};

natives.EventClass = function EventClass(runtime, scope, instance, baseClass) {
  function constructorHook() {
    this.d = runtime.notifyConstruct(this, Array.prototype.slice.call(arguments, 0));
    return instance.apply(this, arguments);
  }

  var c = new runtime.domain.system.Class("Event", constructorHook, Domain.passthroughCallable(constructorHook));
  c.extend(baseClass);

  c.nativeStatics = {};

  c.nativeMethods = {
    // ctor :: type:String, bubbles:Boolean, cancelable:Boolean -> void
    ctor: function ctor(type, bubbles, cancelable) {
      // print("Event.ctor");
    },

    // type :: void -> String
    "get type": function type() {
      return this.nativeObject.type;
    },

    // bubbles :: void -> Boolean
    "get bubbles": function bubbles() {
      return this.nativeObject.bubbles;
    },

    // cancelable :: void -> Boolean
    "get cancelable": function cancelable() {
      return this.nativeObject.cancelable;
    },

    // target :: void -> Object
    "get target": function target() {
      notImplemented("Event.target");
    },

    // currentTarget :: void -> Object
    "get currentTarget": function currentTarget() {
      notImplemented("Event.currentTarget");
    },

    // eventPhase :: void -> uint
    "get eventPhase": function eventPhase() {
      return this.nativeObject.eventPhase;
    },

    // stopPropagation :: void -> void
    stopPropagation: function stopPropagation() {
      notImplemented("Event.stopPropagation");
    },

    // stopImmediatePropagation :: void -> void
    stopImmediatePropagation: function stopImmediatePropagation() {
      notImplemented("Event.stopImmediatePropagation");
    },

    // preventDefault :: void -> void
    preventDefault: function preventDefault() {
      notImplemented("Event.preventDefault");
    },

    // isDefaultPrevented :: void -> Boolean
    isDefaultPrevented: function isDefaultPrevented() {
      // notImplemented("Event.isDefaultPrevented");
      return Boolean(false);
    }
  };

  return c;
};

natives.KeyboardEventClass = function KeyboardEventClass(runtime, scope, instance, baseClass) {
  function constructorHook() {
    this.d = runtime.notifyConstruct(this, Array.prototype.slice.call(arguments, 0));
    var result = instance.apply(this, arguments);
    this.private$flash$events$KeyboardEvent$m_keyCode = this.nativeObject.keyCode;
    this.private$flash$events$KeyboardEvent$m_keyLocation = this.nativeObject.keyLocation;
    return result;
  }

  var c = new runtime.domain.system.Class("KeyboardEvent", constructorHook, Domain.passthroughCallable(constructorHook));
  c.extend(baseClass);

  c.nativeStatics = {};

  c.nativeMethods = {
    // altKey :: void -> Boolean
    "get altKey": function altKey() {
      return this.nativeObject.altKey;
    },

    // altKey :: value:Boolean -> void
    "set altKey": function altKey(value) {
      this.nativeObject.altKey = value;
    },

    // charCode :: charCode -> Number
    "get charCode": function charCode() {
      return this.nativeObject.charCode;
    },

    // charCode :: value:Number -> void
    "set charCode": function charCode(value) {
      this.nativeObject.charCode = value;
    },

    // ctrlKey :: void -> Boolean
    "get ctrlKey": function ctrlKey() {
      return this.nativeObject.ctrlKey;
    },

    // ctrlKey :: value:Boolean -> void
    "set ctrlKey": function ctrlKey(value) {
      this.nativeObject.ctrlKey = value;
    },

    // shiftKey :: void -> Boolean
    "get shiftKey": function shiftKey() {
      return this.nativeObject.shiftKey;
    },

    // shiftKey :: value:Boolean -> void
    "set shiftKey": function shiftKey(value) {
      this.nativeObject.shiftKey = value;
    }
  };

  return c;
};

@@ -4685,20 +4685,14 @@
     
-var result =
+return
  ins
@@ -4713,75 +4713,249 @@
 is, 
-arguments);%0A    this.private$flash$events$KeyboardEvent$m_keyCode =
+%5Bthis.nativeObject.type,%0A                                 this.nativeObject.bubbles,%0A                                 this.nativeObject.cancelable,%0A                                 this.nativeObject.charCode,%0A                                
  thi
@@ -4980,118 +4980,254 @@
 Code
-;
+,
 %0A    
-this.private$flash$events$KeyboardEvent$m_keyLocation = this.nativeObject.keyLocation;%0A    return result
+                             this.nativeObject.keyLocation,%0A                                 this.nativeObject.ctrlKey,%0A                                 this.nativeObject.altKey,%0A                                 this.nativeObject.shiftKey%5D)
 ;%0A  

Use constructor call instead of private properties set