Format all dart: library files

sdk/lib/_internal/js_runtime/lib/string_helper.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of _js_helper;
 
 stringIndexOfStringUnchecked(receiver, other, startIndex) {
   return JS('int', '#.indexOf(#, #)', receiver, other, startIndex);
 }
 
 substring1Unchecked(receiver, startIndex) {
   return JS('String', '#.substring(#)', receiver, startIndex);
 }
 
 substring2Unchecked(receiver, startIndex, endIndex) {
   return JS('String', '#.substring(#, #)', receiver, startIndex, endIndex);
 }
 
 stringContainsStringUnchecked(receiver, other, startIndex) {
   return stringIndexOfStringUnchecked(receiver, other, startIndex) >= 0;
 }
 
 class StringMatch implements Match {
-  const StringMatch(int this.start,
-                    String this.input,
-                    String this.pattern);
+  const StringMatch(int this.start, String this.input, String this.pattern);
 
   int get end => start + pattern.length;
-  String operator[](int g) => group(g);
+  String operator [](int g) => group(g);
   int get groupCount => 0;
 
   String group(int group_) {
     if (group_ != 0) {
       throw new RangeError.value(group_);
     }
     return pattern;
   }
 
   List<String> groups(List<int> groups_) {
     List<String> result = new List<String>();
     for (int g in groups_) {
       result.add(group(g));
     }
     return result;
   }
 
   final int start;
   final String input;
   final String pattern;
 }
 
-Iterable<Match> allMatchesInStringUnchecked(String pattern, String string,
-                                            int startIndex) {
+Iterable<Match> allMatchesInStringUnchecked(
+    String pattern, String string, int startIndex) {
   return new _StringAllMatchesIterable(string, pattern, startIndex);
 }
 
 class _StringAllMatchesIterable extends Iterable<Match> {
   final String _input;
   final String _pattern;
   final int _index;
 
   _StringAllMatchesIterable(this._input, this._pattern, this._index);
 
@@ skipping 59 matching lines @@
 }
 
 stringReplaceFirstRE(receiver, regexp, replacement, startIndex) {
   var match = regexp._execGlobal(receiver, startIndex);
   if (match == null) return receiver;
   var start = match.start;
   var end = match.end;
   return stringReplaceRangeUnchecked(receiver, start, end, replacement);
 }
 
-
 /// Returns a string for a RegExp pattern that matches [string]. This is done by
 /// escaping all RegExp metacharacters.
 quoteStringForRegExp(string) {
   return JS('String', r'#.replace(/[[\]{}()*+?.\\^$|]/g, "\\$&")', string);
 }
 
 stringReplaceAllUnchecked(receiver, pattern, replacement) {
   checkString(replacement);
   if (pattern is String) {
     if (pattern == "") {
@@ skipping 24 matching lines @@
   }
 }
 
 String _matchString(Match match) => match[0];
 String _stringIdentity(String string) => string;
 
 stringReplaceAllFuncUnchecked(receiver, pattern, onMatch, onNonMatch) {
   if (onMatch == null) onMatch = _matchString;
   if (onNonMatch == null) onNonMatch = _stringIdentity;
   if (pattern is String) {
-    return stringReplaceAllStringFuncUnchecked(receiver, pattern,
-                                               onMatch, onNonMatch);
+    return stringReplaceAllStringFuncUnchecked(
+        receiver, pattern, onMatch, onNonMatch);
   }
   // Placing the Pattern test here is indistingishable from placing it at the
   // top of the method but it saves an extra check on the `pattern is String`
   // path.
   if (pattern is! Pattern) {
     throw new ArgumentError.value(pattern, 'pattern', 'is not a Pattern');
   }
   StringBuffer buffer = new StringBuffer('');
   int startIndex = 0;
   for (Match match in pattern.allMatches(receiver)) {
@@ skipping 47 matching lines @@
       break;
     }
     buffer.write(onNonMatch(receiver.substring(startIndex, position)));
     buffer.write(onMatch(new StringMatch(position, receiver, pattern)));
     startIndex = position + patternLength;
   }
   buffer.write(onNonMatch(receiver.substring(startIndex)));
   return buffer.toString();
 }
 
-
 stringReplaceFirstUnchecked(receiver, pattern, replacement, int startIndex) {
   if (pattern is String) {
     int index = stringIndexOfStringUnchecked(receiver, pattern, startIndex);
     if (index < 0) return receiver;
     int end = index + pattern.length;
     return stringReplaceRangeUnchecked(receiver, index, end, replacement);
   }
   if (pattern is JSSyntaxRegExp) {
     return startIndex == 0
         ? stringReplaceJS(receiver, regExpGetNative(pattern), replacement)
         : stringReplaceFirstRE(receiver, pattern, replacement, startIndex);
   }
   checkNull(pattern);
   Iterator<Match> matches = pattern.allMatches(receiver, startIndex).iterator;
   if (!matches.moveNext()) return receiver;
   Match match = matches.current;
   return receiver.replaceRange(match.start, match.end, replacement);
 }
 
-stringReplaceFirstMappedUnchecked(receiver, pattern, replace,
-                                  int startIndex) {
+stringReplaceFirstMappedUnchecked(receiver, pattern, replace, int startIndex) {
   Iterator<Match> matches = pattern.allMatches(receiver, startIndex).iterator;
   if (!matches.moveNext()) return receiver;
   Match match = matches.current;
   String replacement = "${replace(match)}";
   return receiver.replaceRange(match.start, match.end, replacement);
 }
 
 stringJoinUnchecked(array, separator) {
   return JS('String', r'#.join(#)', array, separator);
 }
 
-String stringReplaceRangeUnchecked(String receiver,
-                                   int start, int end, String replacement) {
+String stringReplaceRangeUnchecked(
+    String receiver, int start, int end, String replacement) {
   var prefix = JS('String', '#.substring(0, #)', receiver, start);
   var suffix = JS('String', '#.substring(#)', receiver, end);
   return "$prefix$replacement$suffix";
 }