transform(value: string, mapping: {[key: string]: string}): string {
    if (!isStringMap(mapping)) {
      throw new InvalidPipeArgumentException(I18nSelectPipe, mapping);
    }

    return StringMapWrapper.contains(mapping, value) ? mapping[value] : mapping['other'];
  }

function classSetterFactory(className) {
  var setterFn = StringMapWrapper.get(classSettersCache, className);
  var dashCasedClassName;
  if (isBlank(setterFn)) {
    dashCasedClassName = camelCaseToDashCase(className);
    setterFn = function(element, value) {
      if (value) {
        DOM.addClass(element, dashCasedClassName);
      } else {
        DOM.removeClass(element, dashCasedClassName);
      }
    };
    StringMapWrapper.set(classSettersCache, className, setterFn);
  }
  return setterFn;
}

 new MockStep((parent, current, control) => {
   if (isPresent(propertyBindings)) {
     StringMapWrapper.forEach(propertyBindings, (ast, name) => {
       current.bindElement().bindProperty(name, ast);
     });
   }
 }),

 /** @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;
 }

 describe(): StringMap<string, any> {
   var res = {
     'scriptTime': 'script execution time in ms, including gc and render',
     'pureScriptTime': 'script execution time in ms, without gc nor render'
   };
   if (this._perfLogFeatures.render) {
     res['renderTime'] = 'render time in ms';
   }
   if (this._perfLogFeatures.gc) {
     res['gcTime'] = 'gc time in ms';
     res['gcAmount'] = 'gc amount in kbytes';
     res['majorGcTime'] = 'time of major gcs in ms';
     if (this._forceGc) {
       res['forcedGcTime'] = 'forced gc time in ms';
       res['forcedGcAmount'] = 'forced gc amount in kbytes';
     }
   }
   if (this._captureFrames) {
     res['meanFrameTime'] = this._perfLogFeatures.frameCapture ?
                                'mean frame time in ms (target: 16.6ms for 60fps)' :
                                'WARNING: Metric requested, but not supported by driver';
   }
   StringMapWrapper.forEach(this._microMetrics,
                            (desc, name) => { StringMapWrapper.set(res, name, desc); });
   return res;
 }

function _serializeParams(params: {[key: string]: string}): string {
  let res = "";
  if (isPresent(params)) {
    StringMapWrapper.forEach(params, (v, k) => res += `;${k}=${v}`);
  }
  return res;
}

 static _mergeErrors(control, res) {
   StringMapWrapper.forEach(control.errors, (value, error) => {
     if (!StringMapWrapper.contains(res, error)) {
       res[error] = [];
     }
     ListWrapper.push(res[error], control);
   });
 }

export function equalSegments(a: RouteSegment, b: RouteSegment): boolean {
  if (isBlank(a) && !isBlank(b)) return false;
  if (!isBlank(a) && isBlank(b)) return false;
  if (a._type !== b._type) return false;
  if (isBlank(a.parameters) && !isBlank(b.parameters)) return false;
  if (!isBlank(a.parameters) && isBlank(b.parameters)) return false;
  return StringMapWrapper.equals(a.parameters, b.parameters);
}

 ListWrapper.forEach(modifierKeys, (modifierName) => {
   if (modifierName != key) {
     var modifierGetter = StringMapWrapper.get(modifierKeyGetters, modifierName);
     if (modifierGetter(event)) {
       fullKey += modifierName + '.';
     }
   }
 });

 static _mergeErrors(control: modelModule.AbstractControl, res: StringMap<string, any>): void {
   StringMapWrapper.forEach(control.errors, (value, error) => {
     if (!StringMapWrapper.contains(res, error)) {
       res[error] = [];
     }
     ListWrapper.push(res[error], control);
   });
 }