Change intl to use new pub layout

pkg/intl/lib/bidi_formatter.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.
 
 /**
  * Bidi stands for Bi-directional text.
  * According to [Wikipedia](http://en.wikipedia.org/wiki/Bi-directional_text):
  * Bi-directional text is text containing text in both text directionalities,
  * both right-to-left (RTL) and left-to-right (LTR). It generally involves text
  * containing different types of alphabets, but may also refer to boustrophedon,
@@ skipping 55 matching lines @@
   /**
    * Create a formatting object with a direction. If [alwaysSpan] is true we
    * should always use a `span` tag, even when the input directionality is
    * neutral or matches the context, so that the DOM structure of the output
    * does not depend on the combination of directionalities.
    */
   BidiFormatter.LTR([alwaysSpan=false]) : contextDirection = TextDirection.LTR,
       _alwaysSpan = alwaysSpan;
   BidiFormatter.RTL([alwaysSpan=false]) : contextDirection = TextDirection.RTL,
       _alwaysSpan = alwaysSpan;
-  BidiFormatter.UNKNOWN([alwaysSpan=false]) : 
+  BidiFormatter.UNKNOWN([alwaysSpan=false]) :
       contextDirection = TextDirection.UNKNOWN, _alwaysSpan = alwaysSpan;
 
   /** Is true if the known context direction for this formatter is RTL. */
   bool get isRTL => contextDirection == TextDirection.RTL;
 
   /**
+   * Escapes HTML-special characters of [text] so that the result can be
+   * included verbatim in HTML source code, either in an element body or in an
+   * attribute value.
+   */
+  String htmlEscape(String text) {
+    // TODO(alanknight): This is copied into here directly to avoid having a
+    // dependency on the htmlescape library, which is difficult to do in a way
+    // that's compatible with both package: links and direct links in the SDK.
+    // Once pub is used in test.dart (Issue #4968) this should be removed.
+    // TODO(efortuna): A more efficient implementation.
+    return text.replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&apos;");
+  }
+
+  /**
    * Formats a string of a given (or estimated, if not provided)
    * [direction] for use in HTML output of the context directionality, so
    * an opposite-directionality string is neither garbled nor garbles what
    * follows it.
    * If the input string's directionality doesn't match the context
    * directionality, we wrap it with a `span` tag and add a `dir` attribute
    * (either "dir=rtl" or "dir=ltr").
    * If alwaysSpan was true when constructing the formatter, the input is always
    * wrapped with `span` tag, skipping the dir attribute when it's not needed.
    *
@@ skipping 14 matching lines @@
         spanDirection = ' dir=${direction.spanText}';
       }
       result= '<span$spanDirection>$text</span>';
     } else {
       result = text;
     }
     return result.concat(resetDir? _resetDir(text, direction, isHtml) : '');
   }
 
   /**
-   * Format [text] of a known (if specified) or estimated [direction] for use 
+   * Format [text] of a known (if specified) or estimated [direction] for use
    * in *plain-text* output of the context directionality, so an
    * opposite-directionality text is neither garbled nor garbles what follows
    * it. Unlike wrapWithSpan, this makes use of unicode BiDi formatting
    * characters instead of spans for wrapping. The returned string would be
    * RLE+text+PDF for RTL text, or LRE+text+PDF for LTR text.
    *
    * If [resetDir] is true, and if the overall directionality or the exit
    * directionality of text are opposite to the context directionality,
    * a trailing unicode BiDi mark matching the context directionality is
    * appended (LRM or RLM).
    *
    * In HTML, the *only* valid use of this function is inside of elements that
    * do not allow markup, e.g. an 'option' tag.
    * This function does *not* do HTML-escaping regardless of the value of
    * [isHtml]. [isHtml] is used to designate if the text contains HTML (escaped
    * or unescaped).
    */
   String wrapWithUnicode(String text, [bool isHtml=false, bool resetDir=true,
                      TextDirection direction]) {
     if (direction == null) direction = estimateDirection(text, isHtml);
     var result = text;
     if (contextDirection.isDirectionChange(direction)) {
       result = '''${direction == TextDirection.RTL ? RLE : LRE}$text$PDF''';
     }
     return result.concat(resetDir? _resetDir(text, direction, isHtml) : '');
   }
 
   /**
    * Estimates the directionality of [text] using the best known
-   * general-purpose method (using relative word counts). A 
+   * general-purpose method (using relative word counts). A
    * TextDirection.UNKNOWN return value indicates completely neutral input.
    * [isHtml] is true if [text] HTML or HTML-escaped.
    */
   TextDirection estimateDirection(String text, [bool isHtml=false]) {
     return estimateDirectionOfText(text, isHtml); //TODO~!!!
   }
 
   /**
    * Returns a unicode BiDi mark matching the surrounding context's [direction]
    * (not necessarily the direction of [text]). The function returns an LRM or
    * RLM if the overall directionality or the exit directionality of [text] is
    * opposite the context directionality. Otherwise
-   * return the empty string. [isHtml] is true if [text] is HTML or 
+   * return the empty string. [isHtml] is true if [text] is HTML or
    * HTML-escaped.
    */
   String _resetDir(String text, TextDirection direction, bool isHtml) {
     // endsWithRtl and endsWithLtr are called only if needed (short-circuit).
     if ((contextDirection == TextDirection.LTR &&
           (direction == TextDirection.RTL ||
            endsWithRtl(text, isHtml))) ||
         (contextDirection == TextDirection.RTL &&
           (direction == TextDirection.LTR ||
            endsWithLtr(text, isHtml)))) {
       if (contextDirection == TextDirection.LTR) {
         return LRM;
       } else {
         return RLM;
       }
     } else {
       return '';
     }
   }
 }