[html5lib] triple slash comment style

pkg/third_party/html5lib/lib/src/encoding_parser.dart

 library encoding_parser;
 
 import 'dart:collection';
 import 'constants.dart';
 import 'inputstream.dart';
 
 // TODO(jmesserly): I converted StopIteration to StateError("No more elements").
 // Seems strange to throw this from outside of an iterator though.
-/**
- * String-like object with an associated position and various extra methods
- * If the position is ever greater than the string length then an exception is
- * raised.
- */
+/// String-like object with an associated position and various extra methods
+/// If the position is ever greater than the string length then an exception is
+/// raised.
 class EncodingBytes extends IterableBase<String> {
   final String _bytes;
   int _position = -1;
 
   EncodingBytes(this._bytes);
 
   Iterator<String> get iterator => _bytes.split('').iterator;
 
   int get length => _bytes.length;
 
@@ skipping 31 matching lines @@
     }
     if (_position >= 0) {
       return _position;
     } else {
       return 0;
     }
   }
 
   String get currentByte => _bytes[position];
 
-  /** Skip past a list of characters. Defaults to skipping [isWhitespace]. */
+  /// Skip past a list of characters. Defaults to skipping [isWhitespace].
   String skipChars([CharPreciate skipChars]) {
     if (skipChars == null) skipChars = isWhitespace;
     var p = position;  // use property for the error-checking
     while (p < length) {
       var c = _bytes[p];
       if (!skipChars(c)) {
         _position = p;
         return c;
       }
       p += 1;
     }
     _position = p;
     return null;
   }
 
   String skipUntil(CharPreciate untilChars) {
     var p = position;
     while (p < length) {
       var c = _bytes[p];
       if (untilChars(c)) {
         _position = p;
         return c;
       }
       p += 1;
     }
     return null;
   }
 
-  /**
-   * Look for a sequence of bytes at the start of a string. If the bytes
-   * are found return true and advance the position to the byte after the
-   * match. Otherwise return false and leave the position alone.
-   */
+  /// Look for a sequence of bytes at the start of a string. If the bytes
+  /// are found return true and advance the position to the byte after the
+  /// match. Otherwise return false and leave the position alone.
   bool matchBytes(String bytes) {
     var p = position;
     if (_bytes.length < p + bytes.length) {
       return false;
     }
     var data = _bytes.substring(p, p + bytes.length);
     if (data == bytes) {
       position += bytes.length;
       return true;
     }
     return false;
   }
 
-  /**
-   * Look for the next sequence of bytes matching a given sequence. If
-   * a match is found advance the position to the last byte of the match
-   */
+  /// Look for the next sequence of bytes matching a given sequence. If
+  /// a match is found advance the position to the last byte of the match
   bool jumpTo(String bytes) {
     var newPosition = _bytes.indexOf(bytes, position);
     if (newPosition >= 0) {
       _position = newPosition + bytes.length - 1;
       return true;
     } else {
       throw new StateError("No more elements");
     }
   }
 
   String slice(int start, [int end]) {
     if (end == null) end = length;
     if (end < 0) end += length;
     return _bytes.substring(start, end - start);
   }
 }
 
-/** Mini parser for detecting character encoding from meta elements. */
+/// Mini parser for detecting character encoding from meta elements.
 class EncodingParser {
   final EncodingBytes data;
   String encoding;
 
-  /** [bytes] - the data to work on for encoding detection. */
+  /// [bytes] - the data to work on for encoding detection.
   EncodingParser(List<int> bytes)
       // Note: this is intentionally interpreting bytes as codepoints.
       : data = new EncodingBytes(new String.fromCharCodes(bytes).toLowerCase());
 
   String getEncoding() {
     final methodDispatch = [
       ["<!--", handleComment],
       ["<meta", handleMeta],
       ["</", handlePossibleEndTag],
       ["<!", handleOther],
@@ skipping 17 matching lines @@
         if (!keepParsing) {
           break;
         }
       }
     } on StateError catch (e) {
       // Catch this here to match behavior of Python's StopIteration
     }
     return encoding;
   }
 
-  /** Skip over comments. */
+  /// Skip over comments.
   bool handleComment() => data.jumpTo("-->");
 
   bool handleMeta() {
     if (!isWhitespace(data.currentByte)) {
       // if we have <meta not followed by a space so just keep going
       return true;
     }
     // We have a valid meta element we want to search for attributes
     while (true) {
       // Try to find the next attribute after the current position
@@ skipping 49 matching lines @@
       var attr = getAttribute();
       while (attr != null) {
         attr = getAttribute();
       }
     }
     return true;
   }
 
   bool handleOther() => data.jumpTo(">");
 
-  /**
-   * Return a name,value pair for the next attribute in the stream,
-   * if one is found, or null
-   */
+  /// Return a name,value pair for the next attribute in the stream,
+  /// if one is found, or null
   List<String> getAttribute() {
     // Step 1 (skip chars)
     var c = data.skipChars((x) => x == "/" || isWhitespace(x));
     // Step 2
     if (c == ">" || c == null) {
       return null;
     }
     // Step 3
     var attrName = [];
     var attrValue = [];
@@ skipping 117 matching lines @@
     }
   }
 }
 
 
 bool isSpaceOrAngleBracket(String char) {
   return char == ">" || char == "<" || isWhitespace(char);
 }
 
 typedef bool CharPreciate(String char);