static parseEventName(eventName: string): {[key: string]: string} {
    var parts: string[] = eventName.toLowerCase().split('.');

    var domEventName = parts.shift();
    if ((parts.length === 0) ||
        !(StringWrapper.equals(domEventName, 'keydown') ||
          StringWrapper.equals(domEventName, 'keyup'))) {
      return null;
    }

    var key = KeyEventsPlugin._normalizeKey(parts.pop());

    var fullKey = '';
    modifierKeys.forEach(modifierName => {
      if (ListWrapper.contains(parts, modifierName)) {
        ListWrapper.remove(parts, modifierName);
        fullKey += modifierName + '.';
      }
    });
    fullKey += key;

    if (parts.length != 0 || key.length === 0) {
      // returning null instead of throwing to let another plugin process the event
      return null;
    }
    var result = StringMapWrapper.create();
    StringMapWrapper.set(result, 'domEventName', domEventName);
    StringMapWrapper.set(result, 'fullKey', fullKey);
    return result;
  }

 it('should merge values in provided dictionary', () => {
   var map = StringMapWrapper.create();
   StringMapWrapper.set(map, 'foo', 'bar');
   var headers = new Headers(map);
   expect(headers.get('foo')).toBe('bar');
   expect(headers.getAll('foo')).toEqual(['bar']);
 });

 static group(group: modelModule.ControlGroup): StringMap<string, boolean> {
   var res = {};
   StringMapWrapper.forEach(group.controls, (control, name) => {
     if (group.contains(name) && isPresent(control.errors)) {
       Validators._mergeErrors(control, res);
     }
   });
   return StringMapWrapper.isEmpty(res) ? null : res;
 }

  group(controlsConfig: {[key: string]: any},
        extra: {[key: string]: any} = null): modelModule.ControlGroup {
    var controls = this._reduceControls(controlsConfig);
    var optionals = isPresent(extra) ? StringMapWrapper.get(extra, "optionals") : null;
    var validator = isPresent(extra) ? StringMapWrapper.get(extra, "validator") : null;

    if (isPresent(validator)) {
      return new modelModule.ControlGroup(controls, optionals, validator);
    } else {
      return new modelModule.ControlGroup(controls, optionals);
    }
  }

 /** @internal */
 _reduceControls(controlsConfig: any): {[key: string]: modelModule.AbstractControl} {
   var controls: {[key: string]: modelModule.AbstractControl} = {};
   StringMapWrapper.forEach(controlsConfig, (controlConfig, controlName) => {
     controls[controlName] = this._createControl(controlConfig);
   });
   return controls;
 }

 StringMapWrapper.forEach(control.errors, (value, error) => {
   if (!StringMapWrapper.contains(res, error)) {
     res[error] = [];
   }
   var current: any[] = res[error];
   current.push(control);
 });

 return function(control: modelModule.Control) {
   var res = ListWrapper.reduce(validators, (res, validator) => {
     var errors = validator(control);
     return isPresent(errors) ? StringMapWrapper.merge(res, errors) : res;
   }, {});
   return StringMapWrapper.isEmpty(res) ? null : res;
 };

export function isPropertyUpdated(changes: {[key: string]: any}, viewModel: any): boolean {
  if (!StringMapWrapper.contains(changes, "model")) return false;
  var change = changes["model"];

  if (change.isFirstChange()) return true;
  return !looseIdentical(viewModel, change.currentValue);
}