massive CL is massive

src/site/_includes/language-tour/interfaces/index.markdown

 Interfaces are types that define how you can interact with an object.
 An interface can specify methods,
 constructors,
 instance variables
 (or, more precisely, getters and setters),
 and superinterfaces.
 It doesn't, however, specify the code _inside_ of
 methods and constructors.
 
 Interfaces are handy for specifying APIs
@@ skipping 50 matching lines @@
 
 Here's an example of
 specifying that a class implements multiple interfaces:
 
 {% highlight dart %}
 class Point implements Comparable, Hashable {
   ...
 }
 {% endhighlight %}
 
-<aside class="note" markdown="1">
-  **Note:**
-  Soon you'll be able to treat Dart classes as interfaces.
-  This feature will be useful when creating mock objects for testing.
+<aside>
+  <div class="alert alert-info">
+    <strong>Tip:</strong>
+    Dart classes have implicit interfaces.
+    This feature is useful when creating mock objects for testing.
+  </div>
 </aside>
 
 </section>
 
 
 <section id="interfaces-extending" markdown="1">
 ### Extending an interface
 
 You can create an interface
 that builds on one or more interfaces.
 The new interface is called a _subinterface_,
 and all the interfaces it inherits from are its _superinterfaces_.
 
 Use the **extends** keyword
 to specify which interface (or interfaces) you're adding to.
 Here's an example of creating a subinterface of Hashable:
 
 {% highlight dart %}
 interface HashablePoint extends Hashable {
   num x, y;
 }
 {% endhighlight %}
 
-<aside class="note" markdown="1">
-  **Note:**
-  Technically, interfaces don't have instance variables
-  such as `x` and `y`.
-  What looks like an instance variable is really a
-  shortcut for declaring
-  [getter and setter methods](#classes-getters-and-setters).
+<aside>
+  <div class="alert alert-info">
+    <strong>Note:</strong>
+    Technically, interfaces don't have instance variables
+    such as `x` and `y`.
+    What looks like an instance variable is really a
+    shortcut for declaring
+    [getter and setter methods](#classes-getters-and-setters).
+  </div>
 </aside>
 
 Here's an example of implementing a subinterface
 and checking types.
 
 {% highlight dart %}
 class Point implements HashablePoint {
   num x, y; // Required by HashablePoint
 
   // Required by Hashable
@@ skipping 16 matching lines @@
 {% endhighlight %}
 </section>
 
 
 <section id="interfaces-default-class" markdown="1">
 ### Defining constructors and a default class
 
 An interface can define constructors,
 as long as it specifies a _default class_.
 
-<aside class="note" markdown="1">
-  **Note:**
-  Many of the Dart APIs are implemented as
-  interfaces that have default classes.
-  For example, all of the <a href="#built-in-types">built-in types</a>,
-  including <a href="#numbers">num and int</a>, are interfaces.
+<aside>
+  <div class="alert alert-info">
+    <strong>Note:</strong>
+    Many of the Dart APIs are implemented as
+    interfaces that have default classes.
+    For example, all of the <a href="#built-in-types">built-in types</a>,
+    including <a href="#numbers">num and int</a>, are interfaces.
+  </div>
 </aside>
 
 Use the `default` keyword to specify
 the default class.
 For example:
 
 {% highlight dart %}
 interface ObjectCache default MemoryCache {
   ObjectCache();
   // ...
@@ skipping 23 matching lines @@
 
 
 <section id="interfaces-summary" markdown="1">
 ### Summary of interfaces
 Interfaces are everywhere in Dart,
 from built-in types to
 many of the types defined in the standard Dart libraries.
 Because Dart interfaces can have default classes,
 you can use interface constructors.
 </section>