diff --git a/core/includes/bootstrap.inc b/core/includes/bootstrap.inc
index c7094af..3bac36b 100644
--- a/core/includes/bootstrap.inc
+++ b/core/includes/bootstrap.inc
@@ -4,6 +4,7 @@
 use Drupal\Component\Utility\Settings;
 use Drupal\Component\Utility\String;
 use Drupal\Component\Utility\Timer;
+use Drupal\Component\Utility\Unicode;
 use Drupal\Core\DrupalKernel;
 use Drupal\Core\Database\Database;
 use Drupal\Core\DependencyInjection\ContainerBuilder;
@@ -270,22 +271,6 @@
 const LANGUAGE_RTL = 1;
 
 /**
- * Indicates an error during check for PHP unicode support.
- */
-const UNICODE_ERROR = -1;
-
-/**
- * Indicates that standard PHP (emulated) unicode support is being used.
- */
-const UNICODE_SINGLEBYTE = 0;
-
-/**
- * Indicates that full unicode support with the PHP mbstring extension is being
- * used.
- */
-const UNICODE_MULTIBYTE = 1;
-
-/**
  * Time of the current request in seconds elapsed since the Unix Epoch.
  *
  * This differs from $_SERVER['REQUEST_TIME'], which is stored as a float
@@ -668,7 +653,8 @@ function drupal_environment_initialize() {
   setlocale(LC_ALL, 'C');
 
   // Detect string handling method.
-  unicode_check();
+  require_once DRUPAL_ROOT . '/core/lib/Drupal/Component/Utility/Unicode.php';
+  Unicode::check();
 }
 
 /**
@@ -682,51 +668,6 @@ function drupal_valid_http_host($host) {
 }
 
 /**
- * Checks for Unicode support in PHP and sets the proper settings if possible.
- *
- * Because Drupal needs to be able to handle text in various encodings, we do
- * not support mbstring function overloading. HTTP input/output conversion must
- * be disabled for similar reasons.
- *
- * @return string
- *   A string identifier of a failed multibyte extension check, if any.
- *   Otherwise, an empty string.
- */
-function unicode_check() {
-  global $multibyte;
-
-  // Check for mbstring extension.
-  if (!function_exists('mb_strlen')) {
-    $multibyte = UNICODE_SINGLEBYTE;
-    return 'mb_strlen';
-  }
-
-  // Check mbstring configuration.
-  if (ini_get('mbstring.func_overload') != 0) {
-    $multibyte = UNICODE_ERROR;
-    return 'mbstring.func_overload';
-  }
-  if (ini_get('mbstring.encoding_translation') != 0) {
-    $multibyte = UNICODE_ERROR;
-    return 'mbstring.encoding_translation';
-  }
-  if (ini_get('mbstring.http_input') != 'pass') {
-    $multibyte = UNICODE_ERROR;
-    return 'mbstring.http_input';
-  }
-  if (ini_get('mbstring.http_output') != 'pass') {
-    $multibyte = UNICODE_ERROR;
-    return 'mbstring.http_output';
-  }
-
-  // Set appropriate configuration.
-  mb_internal_encoding('utf-8');
-  mb_language('uni');
-  $multibyte = UNICODE_MULTIBYTE;
-  return '';
-}
-
-/**
  * Sets the base URL, cookie domain, and session name from configuration.
  */
 function drupal_settings_initialize() {
diff --git a/core/includes/theme.maintenance.inc b/core/includes/theme.maintenance.inc
index 578d354..33d44ee 100644
--- a/core/includes/theme.maintenance.inc
+++ b/core/includes/theme.maintenance.inc
@@ -5,6 +5,8 @@
  * Theming for maintenance pages.
  */
 
+use Drupal\Component\Utility\Unicode;
+
 /**
  * Sets up the theming system for maintenance page.
  *
@@ -28,7 +30,7 @@ function _drupal_maintenance_theme() {
   require_once DRUPAL_ROOT . '/core/includes/unicode.inc';
   require_once DRUPAL_ROOT . '/core/includes/file.inc';
   require_once DRUPAL_ROOT . '/core/includes/module.inc';
-  unicode_check();
+  Unicode::check();
 
   // Install and update pages are treated differently to prevent theming overrides.
   if (defined('MAINTENANCE_MODE') && (MAINTENANCE_MODE == 'install' || MAINTENANCE_MODE == 'update')) {
diff --git a/core/includes/unicode.inc b/core/includes/unicode.inc
index 70a8fde..3b3a8da 100644
--- a/core/includes/unicode.inc
+++ b/core/includes/unicode.inc
@@ -5,66 +5,8 @@
  * Provides Unicode-related conversions and operations.
  */
 
-/**
- * Matches Unicode characters that are word boundaries.
- *
- * Characters with the following General_category (gc) property values are used
- * as word boundaries. While this does not fully conform to the Word Boundaries
- * algorithm described in http://unicode.org/reports/tr29, as PCRE does not
- * contain the Word_Break property table, this simpler algorithm has to do.
- * - Cc, Cf, Cn, Co, Cs: Other.
- * - Pc, Pd, Pe, Pf, Pi, Po, Ps: Punctuation.
- * - Sc, Sk, Sm, So: Symbols.
- * - Zl, Zp, Zs: Separators.
- *
- * Non-boundary characters include the following General_category (gc) property
- * values:
- * - Ll, Lm, Lo, Lt, Lu: Letters.
- * - Mc, Me, Mn: Combining Marks.
- * - Nd, Nl, No: Numbers.
- *
- * Note that the PCRE property matcher is not used because we wanted to be
- * compatible with Unicode 5.2.0 regardless of the PCRE version used (and any
- * bugs in PCRE property tables).
- *
- * @see http://unicode.org/glossary
- */
-define('PREG_CLASS_UNICODE_WORD_BOUNDARY',
-  '\x{0}-\x{2F}\x{3A}-\x{40}\x{5B}-\x{60}\x{7B}-\x{A9}\x{AB}-\x{B1}\x{B4}' .
-  '\x{B6}-\x{B8}\x{BB}\x{BF}\x{D7}\x{F7}\x{2C2}-\x{2C5}\x{2D2}-\x{2DF}' .
-  '\x{2E5}-\x{2EB}\x{2ED}\x{2EF}-\x{2FF}\x{375}\x{37E}-\x{385}\x{387}\x{3F6}' .
-  '\x{482}\x{55A}-\x{55F}\x{589}-\x{58A}\x{5BE}\x{5C0}\x{5C3}\x{5C6}' .
-  '\x{5F3}-\x{60F}\x{61B}-\x{61F}\x{66A}-\x{66D}\x{6D4}\x{6DD}\x{6E9}' .
-  '\x{6FD}-\x{6FE}\x{700}-\x{70F}\x{7F6}-\x{7F9}\x{830}-\x{83E}' .
-  '\x{964}-\x{965}\x{970}\x{9F2}-\x{9F3}\x{9FA}-\x{9FB}\x{AF1}\x{B70}' .
-  '\x{BF3}-\x{BFA}\x{C7F}\x{CF1}-\x{CF2}\x{D79}\x{DF4}\x{E3F}\x{E4F}' .
-  '\x{E5A}-\x{E5B}\x{F01}-\x{F17}\x{F1A}-\x{F1F}\x{F34}\x{F36}\x{F38}' .
-  '\x{F3A}-\x{F3D}\x{F85}\x{FBE}-\x{FC5}\x{FC7}-\x{FD8}\x{104A}-\x{104F}' .
-  '\x{109E}-\x{109F}\x{10FB}\x{1360}-\x{1368}\x{1390}-\x{1399}\x{1400}' .
-  '\x{166D}-\x{166E}\x{1680}\x{169B}-\x{169C}\x{16EB}-\x{16ED}' .
-  '\x{1735}-\x{1736}\x{17B4}-\x{17B5}\x{17D4}-\x{17D6}\x{17D8}-\x{17DB}' .
-  '\x{1800}-\x{180A}\x{180E}\x{1940}-\x{1945}\x{19DE}-\x{19FF}' .
-  '\x{1A1E}-\x{1A1F}\x{1AA0}-\x{1AA6}\x{1AA8}-\x{1AAD}\x{1B5A}-\x{1B6A}' .
-  '\x{1B74}-\x{1B7C}\x{1C3B}-\x{1C3F}\x{1C7E}-\x{1C7F}\x{1CD3}\x{1FBD}' .
-  '\x{1FBF}-\x{1FC1}\x{1FCD}-\x{1FCF}\x{1FDD}-\x{1FDF}\x{1FED}-\x{1FEF}' .
-  '\x{1FFD}-\x{206F}\x{207A}-\x{207E}\x{208A}-\x{208E}\x{20A0}-\x{20B8}' .
-  '\x{2100}-\x{2101}\x{2103}-\x{2106}\x{2108}-\x{2109}\x{2114}' .
-  '\x{2116}-\x{2118}\x{211E}-\x{2123}\x{2125}\x{2127}\x{2129}\x{212E}' .
-  '\x{213A}-\x{213B}\x{2140}-\x{2144}\x{214A}-\x{214D}\x{214F}' .
-  '\x{2190}-\x{244A}\x{249C}-\x{24E9}\x{2500}-\x{2775}\x{2794}-\x{2B59}' .
-  '\x{2CE5}-\x{2CEA}\x{2CF9}-\x{2CFC}\x{2CFE}-\x{2CFF}\x{2E00}-\x{2E2E}' .
-  '\x{2E30}-\x{3004}\x{3008}-\x{3020}\x{3030}\x{3036}-\x{3037}' .
-  '\x{303D}-\x{303F}\x{309B}-\x{309C}\x{30A0}\x{30FB}\x{3190}-\x{3191}' .
-  '\x{3196}-\x{319F}\x{31C0}-\x{31E3}\x{3200}-\x{321E}\x{322A}-\x{3250}' .
-  '\x{3260}-\x{327F}\x{328A}-\x{32B0}\x{32C0}-\x{33FF}\x{4DC0}-\x{4DFF}' .
-  '\x{A490}-\x{A4C6}\x{A4FE}-\x{A4FF}\x{A60D}-\x{A60F}\x{A673}\x{A67E}' .
-  '\x{A6F2}-\x{A716}\x{A720}-\x{A721}\x{A789}-\x{A78A}\x{A828}-\x{A82B}' .
-  '\x{A836}-\x{A839}\x{A874}-\x{A877}\x{A8CE}-\x{A8CF}\x{A8F8}-\x{A8FA}' .
-  '\x{A92E}-\x{A92F}\x{A95F}\x{A9C1}-\x{A9CD}\x{A9DE}-\x{A9DF}' .
-  '\x{AA5C}-\x{AA5F}\x{AA77}-\x{AA79}\x{AADE}-\x{AADF}\x{ABEB}' .
-  '\x{E000}-\x{F8FF}\x{FB29}\x{FD3E}-\x{FD3F}\x{FDFC}-\x{FDFD}' .
-  '\x{FE10}-\x{FE19}\x{FE30}-\x{FE6B}\x{FEFF}-\x{FF0F}\x{FF1A}-\x{FF20}' .
-  '\x{FF3B}-\x{FF40}\x{FF5B}-\x{FF65}\x{FFE0}-\x{FFFD}');
+use Drupal\Component\Utility\Unicode;
+use Drupal\Component\Utility\String;
 
 /**
  * Returns Unicode library status and errors.
@@ -83,7 +25,7 @@ function unicode_requirements() {
     UNICODE_MULTIBYTE => NULL,
     UNICODE_ERROR => REQUIREMENT_ERROR,
   );
-  $failed_check = unicode_check();
+  $failed_check = Unicode::check();
   $library = $GLOBALS['multibyte'];
 
   $requirements['unicode'] = array(
@@ -176,29 +118,20 @@ function drupal_xml_parser_create(&$data) {
 /**
  * Converts data to UTF-8.
  *
- * Requires the iconv, GNU recode or mbstring PHP extension.
- *
- * @param $data
+ * @param string $data
  *   The data to be converted.
- * @param $encoding
+ * @param string $encoding
  *   The encoding that the data is in.
  *
- * @return
+ * @return string|bool
  *   Converted data or FALSE.
+ *
+ * @see \Drupal\Component\Utility\Unicode::convertToUtf8().
  */
 function drupal_convert_to_utf8($data, $encoding) {
-  if (function_exists('iconv')) {
-    $out = @iconv($encoding, 'utf-8', $data);
-  }
-  elseif (function_exists('mb_convert_encoding')) {
-    $out = @mb_convert_encoding($data, 'utf-8', $encoding);
-  }
-  elseif (function_exists('recode_string')) {
-    $out = @recode_string($encoding . '..utf-8', $data);
-  }
-  else {
+  $out = Unicode::convertToUtf8($data, $encoding);
+  if ($out === FALSE) {
     watchdog('php', 'Unsupported encoding %s. Please install iconv, GNU recode or mbstring for PHP.', array('%s' => $encoding), WATCHDOG_ERROR);
-    return FALSE;
   }
 
   return $out;
@@ -207,33 +140,18 @@ function drupal_convert_to_utf8($data, $encoding) {
 /**
  * Truncates a UTF-8-encoded string safely to a number of bytes.
  *
- * If the end position is in the middle of a UTF-8 sequence, it scans backwards
- * until the beginning of the byte sequence.
- *
- * Use this function whenever you want to chop off a string at an unsure
- * location. On the other hand, if you're sure that you're splitting on a
- * character boundary (e.g. after using strpos() or similar), you can safely
- * use substr() instead.
- *
- * @param $string
+ * @param string $string
  *   The string to truncate.
- * @param $len
+ * @param int $len
  *   An upper limit on the returned string length.
  *
- * @return
+ * @return string
  *   The truncated string.
+ *
+ * @see \Drupal\Component\Utility\Unicode::truncateBytes().
  */
 function drupal_truncate_bytes($string, $len) {
-  if (strlen($string) <= $len) {
-    return $string;
-  }
-  if ((ord($string[$len]) < 0x80) || (ord($string[$len]) >= 0xC0)) {
-    return substr($string, 0, $len);
-  }
-  // Scan backwards to beginning of the byte sequence.
-  while (--$len >= 0 && ord($string[$len]) >= 0x80 && ord($string[$len]) < 0xC0);
-
-  return substr($string, 0, $len);
+  return Unicode::truncateBytes($string, $len);
 }
 
 /**
@@ -247,7 +165,7 @@ function drupal_truncate_bytes($string, $len) {
  * @param $wordsafe
  *   If TRUE, attempt to truncate on a word boundary. Word boundaries are
  *   spaces, punctuation, and Unicode characters used as word boundaries in
- *   non-Latin languages; see PREG_CLASS_UNICODE_WORD_BOUNDARY for more
+ *   non-Latin languages; see Unicode::PREG_CLASS_WORD_BOUNDARY for more
  *   information. If a word boundary cannot be found that would make the length
  *   of the returned string fall within length guidelines (see parameters
  *   $max_length and $min_wordsafe_length), word boundaries are ignored.
@@ -269,70 +187,16 @@ function drupal_truncate_bytes($string, $len) {
  *
  * @return string
  *   The truncated string.
+ *
+ * @see \Drupal\Component\Utility\Unicode::truncate().
  */
 function truncate_utf8($string, $max_length, $wordsafe = FALSE, $add_ellipsis = FALSE, $min_wordsafe_length = 1) {
-  $ellipsis = '';
-  $max_length = max($max_length, 0);
-  $min_wordsafe_length = max($min_wordsafe_length, 0);
-
-  if (drupal_strlen($string) <= $max_length) {
-    // No truncation needed, so don't add ellipsis, just return.
-    return $string;
-  }
-
-  if ($add_ellipsis) {
-    // Truncate ellipsis in case $max_length is small.
-    $ellipsis = drupal_substr(t('…'), 0, $max_length);
-    $max_length -= drupal_strlen($ellipsis);
-    $max_length = max($max_length, 0);
-  }
-
-  if ($max_length <= $min_wordsafe_length) {
-    // Do not attempt word-safe if lengths are bad.
-    $wordsafe = FALSE;
-  }
-
-  if ($wordsafe) {
-    $matches = array();
-    // Find the last word boundary, if there is one within $min_wordsafe_length
-    // to $max_length characters. preg_match() is always greedy, so it will
-    // find the longest string possible.
-    $found = preg_match('/^(.{' . $min_wordsafe_length . ',' . $max_length . '})[' . PREG_CLASS_UNICODE_WORD_BOUNDARY . ']/u', $string, $matches);
-    if ($found) {
-      $string = $matches[1];
-    }
-    else {
-      $string = drupal_substr($string, 0, $max_length);
-    }
-  }
-  else {
-    $string = drupal_substr($string, 0, $max_length);
-  }
-
-  if ($add_ellipsis) {
-    // If we're adding an ellipsis, remove any trailing periods.
-    $string = rtrim($string, '.');
-
-    $string .= $ellipsis;
-  }
-
-  return $string;
+  return String::truncate($string, $max_length, $wordsafe, $add_ellipsis, $min_wordsafe_length);
 }
 
 /**
  * Encodes MIME/HTTP header values that contain incorrectly encoded characters.
  *
- * For example, mime_header_encode('tést.txt') returns "=?UTF-8?B?dMOpc3QudHh0?=".
- *
- * See http://www.rfc-editor.org/rfc/rfc2047.txt for more information.
- *
- * Notes:
- * - Only encode strings that contain non-ASCII characters.
- * - We progressively cut-off a chunk with truncate_utf8(). This is to ensure
- *   each chunk starts and ends on a character boundary.
- * - Using \n as the chunk separator may cause problems on some systems and may
- *   have to be changed to \r\n or \r.
- *
  * @param $string
  *   The header to encode.
  *
@@ -340,22 +204,10 @@ function truncate_utf8($string, $max_length, $wordsafe = FALSE, $add_ellipsis =
  *   The mime-encoded header.
  *
  * @see mime_header_decode()
+ * @see \Drupal\Component\Utility\Unicode::mimeHeaderEncode().
  */
 function mime_header_encode($string) {
-  if (preg_match('/[^\x20-\x7E]/', $string)) {
-    $chunk_size = 47; // floor((75 - strlen("=?UTF-8?B??=")) * 0.75);
-    $len = strlen($string);
-    $output = '';
-    while ($len > 0) {
-      $chunk = drupal_truncate_bytes($string, $chunk_size);
-      $output .= ' =?UTF-8?B?' . base64_encode($chunk) . "?=\n";
-      $c = strlen($chunk);
-      $string = substr($string, $c);
-      $len -= $c;
-    }
-    return trim($output);
-  }
-  return $string;
+  return Unicode::mimeHeaderEncode($string);
 }
 
 /**
@@ -368,78 +220,41 @@ function mime_header_encode($string) {
  *   The mime-decoded header.
  *
  * @see mime_header_encode()
+ * @see \Drupal\Component\Utility\Unicode::mimeHeaderDecode().
  */
 function mime_header_decode($header) {
-  // First step: encoded chunks followed by other encoded chunks (need to collapse whitespace)
-  $header = preg_replace_callback('/=\?([^?]+)\?(Q|B)\?([^?]+|\?(?!=))\?=\s+(?==\?)/', '_mime_header_decode', $header);
-  // Second step: remaining chunks (do not collapse whitespace)
-  return preg_replace_callback('/=\?([^?]+)\?(Q|B)\?([^?]+|\?(?!=))\?=/', '_mime_header_decode', $header);
-}
-
-/**
- * Decodes encoded header data passed from mime_header_decode().
- *
- * Callback for preg_replace_callback() within mime_header_decode().
- *
- * @param $matches
- *   The array of matches from preg_replace_callback().
- *
- * @return string
- *   The mime-decoded string.
- *
- * @see mime_header_decode()
- */
-function _mime_header_decode($matches) {
-  // Regexp groups:
-  // 1: Character set name
-  // 2: Escaping method (Q or B)
-  // 3: Encoded data
-  $data = ($matches[2] == 'B') ? base64_decode($matches[3]) : str_replace('_', ' ', quoted_printable_decode($matches[3]));
-  if (strtolower($matches[1]) != 'utf-8') {
-    $data = drupal_convert_to_utf8($data, $matches[1]);
-  }
-  return $data;
+  return Unicode::mimeHeaderDecode($string);
 }
 
 /**
  * Decodes all HTML entities (including numerical ones) to regular UTF-8 bytes.
  *
- * Double-escaped entities will only be decoded once ("&amp;lt;" becomes "&lt;"
- * , not "<"). Be careful when using this function, as decode_entities can
- * revert previous sanitization efforts (&lt;script&gt; will become <script>).
- *
  * @param $text
  *   The text to decode entities in.
  *
  * @return
  *   The input $text, with all HTML entities decoded once.
+ *
+ * @see \Drupal\Component\Utility\Unicode::decodeEntities().
  */
 function decode_entities($text) {
-  return html_entity_decode($text, ENT_QUOTES, 'UTF-8');
+  return Unicode::decodeEntities($text);
 }
 
 /**
  * Counts the number of characters in a UTF-8 string.
  *
- * This is less than or equal to the byte count.
- *
  * @param $text
  *   The string to run the operation on.
  *
  * @return integer
  *   The length of the string.
  *
+ * @see \Drupal\Component\Utility\String::length().
  * @ingroup php_wrappers
  */
 function drupal_strlen($text) {
-  global $multibyte;
-  if ($multibyte == UNICODE_MULTIBYTE) {
-    return mb_strlen($text);
-  }
-  else {
-    // Do not count UTF-8 continuation bytes.
-    return strlen(preg_replace("/[\x80-\xBF]/", '', $text));
-  }
+  return String::length($text);
 }
 
 /**
@@ -451,20 +266,11 @@ function drupal_strlen($text) {
  * @return string
  *   The string in uppercase.
  *
+ * @see \Drupal\Component\Utility\String::toUpperCase().
  * @ingroup php_wrappers
  */
 function drupal_strtoupper($text) {
-  global $multibyte;
-  if ($multibyte == UNICODE_MULTIBYTE) {
-    return mb_strtoupper($text);
-  }
-  else {
-    // Use C-locale for ASCII-only uppercase
-    $text = strtoupper($text);
-    // Case flip Latin-1 accented letters
-    $text = preg_replace_callback('/\xC3[\xA0-\xB6\xB8-\xBE]/', '_unicode_caseflip', $text);
-    return $text;
-  }
+  return String::toUpperCase($text);
 }
 
 /**
@@ -476,35 +282,11 @@ function drupal_strtoupper($text) {
  * @return string
  *   The string in lowercase.
  *
+ * @see \Drupal\Component\Utility\String::toLowerCase().
  * @ingroup php_wrappers
  */
 function drupal_strtolower($text) {
-  global $multibyte;
-  if ($multibyte == UNICODE_MULTIBYTE) {
-    return mb_strtolower($text);
-  }
-  else {
-    // Use C-locale for ASCII-only lowercase
-    $text = strtolower($text);
-    // Case flip Latin-1 accented letters
-    $text = preg_replace_callback('/\xC3[\x80-\x96\x98-\x9E]/', '_unicode_caseflip', $text);
-    return $text;
-  }
-}
-
-/**
- * Flips U+C0-U+DE to U+E0-U+FD and back.
- *
- * @param $matches
- *   An array of matches.
- *
- * @return array
- *   The Latin-1 version of the array of matches.
- *
- * @see drupal_strtolower()
- */
-function _unicode_caseflip($matches) {
-  return $matches[0][0] . chr(ord($matches[0][1]) ^ 32);
+  return String::toLowerCase($text);
 }
 
 /**
@@ -516,20 +298,16 @@ function _unicode_caseflip($matches) {
  * @return
  *   The string with the first letter as uppercase.
  *
+ * @see \Drupal\Component\Utility\String::upperCaseFirst().
  * @ingroup php_wrappers
  */
 function drupal_ucfirst($text) {
-  // Note: no mbstring equivalent!
-  return drupal_strtoupper(drupal_substr($text, 0, 1)) . drupal_substr($text, 1);
+  return String::upperCaseFirst($text);
 }
 
 /**
  * Cuts off a piece of a string based on character indices and counts.
  *
- * Follows the same behavior as PHP's own substr() function. Note that for
- * cutting off a string at a known character/substring location, the usage of
- * PHP's normal strpos/substr is safe and much faster.
- *
  * @param $text
  *   The input string.
  * @param $start
@@ -540,92 +318,9 @@ function drupal_ucfirst($text) {
  * @return
  *   The shortened string.
  *
+ * @see \Drupal\Component\Utility\String::toUpper().
  * @ingroup php_wrappers
  */
 function drupal_substr($text, $start, $length = NULL) {
-  global $multibyte;
-  if ($multibyte == UNICODE_MULTIBYTE) {
-    return $length === NULL ? mb_substr($text, $start) : mb_substr($text, $start, $length);
-  }
-  else {
-    $strlen = strlen($text);
-    // Find the starting byte offset.
-    $bytes = 0;
-    if ($start > 0) {
-      // Count all the continuation bytes from the start until we have found
-      // $start characters or the end of the string.
-      $bytes = -1; $chars = -1;
-      while ($bytes < $strlen - 1 && $chars < $start) {
-        $bytes++;
-        $c = ord($text[$bytes]);
-        if ($c < 0x80 || $c >= 0xC0) {
-          $chars++;
-        }
-      }
-    }
-    elseif ($start < 0) {
-      // Count all the continuation bytes from the end until we have found
-      // abs($start) characters.
-      $start = abs($start);
-      $bytes = $strlen; $chars = 0;
-      while ($bytes > 0 && $chars < $start) {
-        $bytes--;
-        $c = ord($text[$bytes]);
-        if ($c < 0x80 || $c >= 0xC0) {
-          $chars++;
-        }
-      }
-    }
-    $istart = $bytes;
-
-    // Find the ending byte offset.
-    if ($length === NULL) {
-      $iend = $strlen;
-    }
-    elseif ($length > 0) {
-      // Count all the continuation bytes from the starting index until we have
-      // found $length characters or reached the end of the string, then
-      // backtrace one byte.
-      $iend = $istart - 1;
-      $chars = -1;
-      $last_real = FALSE;
-      while ($iend < $strlen - 1 && $chars < $length) {
-        $iend++;
-        $c = ord($text[$iend]);
-        $last_real = FALSE;
-        if ($c < 0x80 || $c >= 0xC0) {
-          $chars++;
-          $last_real = TRUE;
-        }
-      }
-      // Backtrace one byte if the last character we found was a real character
-      // and we don't need it.
-      if ($last_real && $chars >= $length) {
-        $iend--;
-      }
-    }
-    elseif ($length < 0) {
-      // Count all the continuation bytes from the end until we have found
-      // abs($start) characters, then backtrace one byte.
-      $length = abs($length);
-      $iend = $strlen; $chars = 0;
-      while ($iend > 0 && $chars < $length) {
-        $iend--;
-        $c = ord($text[$iend]);
-        if ($c < 0x80 || $c >= 0xC0) {
-          $chars++;
-        }
-      }
-      // Backtrace one byte if we are not at the beginning of the string.
-      if ($iend > 0) {
-        $iend--;
-      }
-    }
-    else {
-      // $length == 0, return an empty string.
-      return '';
-    }
-
-    return substr($text, $istart, max(0, $iend - $istart + 1));
-  }
+  return String::substract($text, $start, $length);
 }
diff --git a/core/lib/Drupal/Component/Utility/String.php b/core/lib/Drupal/Component/Utility/String.php
index c79b5af..3bfa56d 100644
--- a/core/lib/Drupal/Component/Utility/String.php
+++ b/core/lib/Drupal/Component/Utility/String.php
@@ -7,6 +7,8 @@
 
 namespace Drupal\Component\Utility;
 
+use Drupal\Component\Utility\Unicode;
+
 /**
  * Provides helpers to operate on strings.
  */
@@ -105,4 +107,270 @@ public static function placeholder($text) {
     return '<em class="placeholder">' . static::checkPlain($text) . '</em>';
   }
 
+  /**
+   * Counts the number of characters in a UTF-8 string.
+   *
+   * This is less than or equal to the byte count.
+   *
+   * @param string $text
+   *   The string to run the operation on.
+   *
+   * @return int
+   *   The length of the string.
+   */
+  public static function length($text) {
+    if (Unicode::$status == Unicode::STATUS_MULTIBYTE) {
+      return mb_strlen($text);
+    }
+    else {
+      // Do not count UTF-8 continuation bytes.
+      return strlen(preg_replace("/[\x80-\xBF]/", '', $text));
+    }
+  }
+
+  /**
+   * Uppercase a UTF-8 string.
+   *
+   * @param string $text
+   *   The string to run the operation on.
+   *
+   * @return string
+   *   The string in uppercase.
+   */
+  public static function toUpperCase($text) {
+    if (Unicode::$status == Unicode::STATUS_MULTIBYTE) {
+      return mb_strtoupper($text);
+    }
+    else {
+      // Use C-locale for ASCII-only uppercase
+      $text = strtoupper($text);
+      // Case flip Latin-1 accented letters
+      $text = preg_replace_callback('/\xC3[\xA0-\xB6\xB8-\xBE]/', array('Unicode', 'caseFlip') , $text);
+      return $text;
+    }
+  }
+
+  /**
+   * Lowercase a UTF-8 string.
+   *
+   * @param string $text
+   *   The string to run the operation on.
+   *
+   * @return string
+   *   The string in lowercase.
+   */
+  public static function toLowerCase($text) {
+    global $multibyte;
+    if (Unicode::$status == Unicode::STATUS_MULTIBYTE) {
+      return mb_strtolower($text);
+    }
+    else {
+      // Use C-locale for ASCII-only lowercase
+      $text = strtolower($text);
+      // Case flip Latin-1 accented letters
+      $text = preg_replace_callback('/\xC3[\x80-\x96\x98-\x9E]/', array('Unicode', 'caseFlip'), $text);
+      return $text;
+    }
+  }
+
+  /**
+   * Capitalizes the first letter of a UTF-8 string.
+   *
+   * @param string $text
+   *   The string to convert.
+   *
+   * @return string
+   *   The string with the first letter as uppercase.
+   */
+  public static function upperCaseFirst($text) {
+    return static::toUpperCase(static::substract($text, 0, 1)) . static::substract($text, 1);
+  }
+
+  /**
+   * Cuts off a piece of a string based on character indices and counts.
+   *
+   * Follows the same behavior as PHP's own substr() function. Note that for
+   * cutting off a string at a known character/substring location, the usage of
+   * PHP's normal strpos/substr is safe and much faster.
+   *
+   * @param string $text
+   *   The input string.
+   * @param int $start
+   *   The position at which to start reading.
+   * @param int $length
+   *   The number of characters to read.
+   *
+   * @return string
+   *   The shortened string.
+   */
+  public static function substract($text, $start, $length = NULL) {
+    if (Unicode::$status == Unicode::STATUS_MULTIBYTE) {
+      return $length === NULL ? mb_substr($text, $start) : mb_substr($text, $start, $length);
+    }
+    else {
+      $strlen = strlen($text);
+      // Find the starting byte offset.
+      $bytes = 0;
+      if ($start > 0) {
+        // Count all the continuation bytes from the start until we have found
+        // $start characters or the end of the string.
+        $bytes = -1; $chars = -1;
+        while ($bytes < $strlen - 1 && $chars < $start) {
+          $bytes++;
+          $c = ord($text[$bytes]);
+          if ($c < 0x80 || $c >= 0xC0) {
+            $chars++;
+          }
+        }
+      }
+      elseif ($start < 0) {
+        // Count all the continuation bytes from the end until we have found
+        // abs($start) characters.
+        $start = abs($start);
+        $bytes = $strlen; $chars = 0;
+        while ($bytes > 0 && $chars < $start) {
+          $bytes--;
+          $c = ord($text[$bytes]);
+          if ($c < 0x80 || $c >= 0xC0) {
+            $chars++;
+          }
+        }
+      }
+      $istart = $bytes;
+
+      // Find the ending byte offset.
+      if ($length === NULL) {
+        $iend = $strlen;
+      }
+      elseif ($length > 0) {
+        // Count all the continuation bytes from the starting index until we have
+        // found $length characters or reached the end of the string, then
+        // backtrace one byte.
+        $iend = $istart - 1;
+        $chars = -1;
+        $last_real = FALSE;
+        while ($iend < $strlen - 1 && $chars < $length) {
+          $iend++;
+          $c = ord($text[$iend]);
+          $last_real = FALSE;
+          if ($c < 0x80 || $c >= 0xC0) {
+            $chars++;
+            $last_real = TRUE;
+          }
+        }
+        // Backtrace one byte if the last character we found was a real character
+        // and we don't need it.
+        if ($last_real && $chars >= $length) {
+          $iend--;
+        }
+      }
+      elseif ($length < 0) {
+        // Count all the continuation bytes from the end until we have found
+        // abs($start) characters, then backtrace one byte.
+        $length = abs($length);
+        $iend = $strlen; $chars = 0;
+        while ($iend > 0 && $chars < $length) {
+          $iend--;
+          $c = ord($text[$iend]);
+          if ($c < 0x80 || $c >= 0xC0) {
+            $chars++;
+          }
+        }
+        // Backtrace one byte if we are not at the beginning of the string.
+        if ($iend > 0) {
+          $iend--;
+        }
+      }
+      else {
+        // $length == 0, return an empty string.
+        return '';
+      }
+
+      return substr($text, $istart, max(0, $iend - $istart + 1));
+    }
+  }
+
+  /**
+   * Truncates a UTF-8-encoded string safely to a number of characters.
+   *
+   * @param string $string
+   *   The string to truncate.
+   * @param int $max_length
+   *   An upper limit on the returned string length, including trailing ellipsis
+   *   if $add_ellipsis is TRUE.
+   * @param bool $wordsafe
+   *   If TRUE, attempt to truncate on a word boundary. Word boundaries are
+   *   spaces, punctuation, and Unicode characters used as word boundaries in
+   *   non-Latin languages; see Unicode::PREG_CLASS_WORD_BOUNDARY for more
+   *   information. If a word boundary cannot be found that would make the length
+   *   of the returned string fall within length guidelines (see parameters
+   *   $max_length and $min_wordsafe_length), word boundaries are ignored.
+   * @param bool $add_ellipsis
+   *   If TRUE, add '...' to the end of the truncated string (defaults to
+   *   FALSE). The string length will still fall within $max_length.
+   * @param bool $min_wordsafe_length
+   *   If $wordsafe is TRUE, the minimum acceptable length for truncation (before
+   *   adding an ellipsis, if $add_ellipsis is TRUE). Has no effect if $wordsafe
+   *   is FALSE. This can be used to prevent having a very short resulting string
+   *   that will not be understandable. For instance, if you are truncating the
+   *   string "See myverylongurlexample.com for more information" to a word-safe
+   *   return length of 20, the only available word boundary within 20 characters
+   *   is after the word "See", which wouldn't leave a very informative string. If
+   *   you had set $min_wordsafe_length to 10, though, the function would realise
+   *   that "See" alone is too short, and would then just truncate ignoring word
+   *   boundaries, giving you "See myverylongurl..." (assuming you had set
+   *   $add_ellipses to TRUE).
+   *
+   * @return string
+   *   The truncated string.
+   */
+  public static function truncate($string, $max_length, $wordsafe = FALSE, $add_ellipsis = FALSE, $min_wordsafe_length = 1) {
+    $ellipsis = '';
+    $max_length = max($max_length, 0);
+    $min_wordsafe_length = max($min_wordsafe_length, 0);
+
+    if (static::length($string) <= $max_length) {
+      // No truncation needed, so don't add ellipsis, just return.
+      return $string;
+    }
+
+    if ($add_ellipsis) {
+      // Truncate ellipsis in case $max_length is small.
+      $ellipsis = static::substract('…', 0, $max_length);
+      $max_length -= static::length($ellipsis);
+      $max_length = max($max_length, 0);
+    }
+
+    if ($max_length <= $min_wordsafe_length) {
+      // Do not attempt word-safe if lengths are bad.
+      $wordsafe = FALSE;
+    }
+
+    if ($wordsafe) {
+      $matches = array();
+      // Find the last word boundary, if there is one within $min_wordsafe_length
+      // to $max_length characters. preg_match() is always greedy, so it will
+      // find the longest string possible.
+      $found = preg_match('/^(.{' . $min_wordsafe_length . ',' . $max_length . '})[' . Unicode::PREG_CLASS_WORD_BOUNDARY . ']/u', $string, $matches);
+      if ($found) {
+        $string = $matches[1];
+      }
+      else {
+        $string = static::substract($string, 0, $max_length);
+      }
+    }
+    else {
+      $string = static::substract($string, 0, $max_length);
+    }
+
+    if ($add_ellipsis) {
+      // If we're adding an ellipsis, remove any trailing periods.
+      $string = rtrim($string, '.');
+
+      $string .= $ellipsis;
+    }
+
+    return $string;
+  }
+
 }
diff --git a/core/lib/Drupal/Component/Utility/Unicode.php b/core/lib/Drupal/Component/Utility/Unicode.php
new file mode 100644
index 0000000..e26ab90
--- /dev/null
+++ b/core/lib/Drupal/Component/Utility/Unicode.php
@@ -0,0 +1,311 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Component\Utility\Unicode.
+ */
+
+namespace Drupal\Component\Utility;
+
+/**
+ * Provides Unicode-related conversions and operations.
+ */
+class Unicode {
+
+  /**
+   * Matches Unicode characters that are word boundaries.
+   *
+   * Characters with the following General_category (gc) property values are used
+   * as word boundaries. While this does not fully conform to the Word Boundaries
+   * algorithm described in http://unicode.org/reports/tr29, as PCRE does not
+   * contain the Word_Break property table, this simpler algorithm has to do.
+   * - Cc, Cf, Cn, Co, Cs: Other.
+   * - Pc, Pd, Pe, Pf, Pi, Po, Ps: Punctuation.
+   * - Sc, Sk, Sm, So: Symbols.
+   * - Zl, Zp, Zs: Separators.
+   *
+   * Non-boundary characters include the following General_category (gc) property
+   * values:
+   * - Ll, Lm, Lo, Lt, Lu: Letters.
+   * - Mc, Me, Mn: Combining Marks.
+   * - Nd, Nl, No: Numbers.
+   *
+   * Note that the PCRE property matcher is not used because we wanted to be
+   * compatible with Unicode 5.2.0 regardless of the PCRE version used (and any
+   * bugs in PCRE property tables).
+   *
+   * @see http://unicode.org/glossary
+   */
+  const PREG_CLASS_WORD_BOUNDARY = <<< 'EOD'
+\x{0}-\x{2F}\x{3A}-\x{40}\x{5B}-\x{60}\x{7B}-\x{A9}\x{AB}-\x{B1}\x{B4}
+\x{B6}-\x{B8}\x{BB}\x{BF}\x{D7}\x{F7}\x{2C2}-\x{2C5}\x{2D2}-\x{2DF}
+\x{2E5}-\x{2EB}\x{2ED}\x{2EF}-\x{2FF}\x{375}\x{37E}-\x{385}\x{387}\x{3F6}
+\x{482}\x{55A}-\x{55F}\x{589}-\x{58A}\x{5BE}\x{5C0}\x{5C3}\x{5C6}
+\x{5F3}-\x{60F}\x{61B}-\x{61F}\x{66A}-\x{66D}\x{6D4}\x{6DD}\x{6E9}
+\x{6FD}-\x{6FE}\x{700}-\x{70F}\x{7F6}-\x{7F9}\x{830}-\x{83E}
+\x{964}-\x{965}\x{970}\x{9F2}-\x{9F3}\x{9FA}-\x{9FB}\x{AF1}\x{B70}
+\x{BF3}-\x{BFA}\x{C7F}\x{CF1}-\x{CF2}\x{D79}\x{DF4}\x{E3F}\x{E4F}
+\x{E5A}-\x{E5B}\x{F01}-\x{F17}\x{F1A}-\x{F1F}\x{F34}\x{F36}\x{F38}
+\x{F3A}-\x{F3D}\x{F85}\x{FBE}-\x{FC5}\x{FC7}-\x{FD8}\x{104A}-\x{104F}
+\x{109E}-\x{109F}\x{10FB}\x{1360}-\x{1368}\x{1390}-\x{1399}\x{1400}
+\x{166D}-\x{166E}\x{1680}\x{169B}-\x{169C}\x{16EB}-\x{16ED}
+\x{1735}-\x{1736}\x{17B4}-\x{17B5}\x{17D4}-\x{17D6}\x{17D8}-\x{17DB}
+\x{1800}-\x{180A}\x{180E}\x{1940}-\x{1945}\x{19DE}-\x{19FF}
+\x{1A1E}-\x{1A1F}\x{1AA0}-\x{1AA6}\x{1AA8}-\x{1AAD}\x{1B5A}-\x{1B6A}
+\x{1B74}-\x{1B7C}\x{1C3B}-\x{1C3F}\x{1C7E}-\x{1C7F}\x{1CD3}\x{1FBD}
+\x{1FBF}-\x{1FC1}\x{1FCD}-\x{1FCF}\x{1FDD}-\x{1FDF}\x{1FED}-\x{1FEF}
+\x{1FFD}-\x{206F}\x{207A}-\x{207E}\x{208A}-\x{208E}\x{20A0}-\x{20B8}
+\x{2100}-\x{2101}\x{2103}-\x{2106}\x{2108}-\x{2109}\x{2114}
+\x{2116}-\x{2118}\x{211E}-\x{2123}\x{2125}\x{2127}\x{2129}\x{212E}
+\x{213A}-\x{213B}\x{2140}-\x{2144}\x{214A}-\x{214D}\x{214F}
+\x{2190}-\x{244A}\x{249C}-\x{24E9}\x{2500}-\x{2775}\x{2794}-\x{2B59}
+\x{2CE5}-\x{2CEA}\x{2CF9}-\x{2CFC}\x{2CFE}-\x{2CFF}\x{2E00}-\x{2E2E}
+\x{2E30}-\x{3004}\x{3008}-\x{3020}\x{3030}\x{3036}-\x{3037}
+\x{303D}-\x{303F}\x{309B}-\x{309C}\x{30A0}\x{30FB}\x{3190}-\x{3191}
+\x{3196}-\x{319F}\x{31C0}-\x{31E3}\x{3200}-\x{321E}\x{322A}-\x{3250}
+\x{3260}-\x{327F}\x{328A}-\x{32B0}\x{32C0}-\x{33FF}\x{4DC0}-\x{4DFF}
+\x{A490}-\x{A4C6}\x{A4FE}-\x{A4FF}\x{A60D}-\x{A60F}\x{A673}\x{A67E}
+\x{A6F2}-\x{A716}\x{A720}-\x{A721}\x{A789}-\x{A78A}\x{A828}-\x{A82B}
+\x{A836}-\x{A839}\x{A874}-\x{A877}\x{A8CE}-\x{A8CF}\x{A8F8}-\x{A8FA}
+\x{A92E}-\x{A92F}\x{A95F}\x{A9C1}-\x{A9CD}\x{A9DE}-\x{A9DF}
+\x{AA5C}-\x{AA5F}\x{AA77}-\x{AA79}\x{AADE}-\x{AADF}\x{ABEB}
+\x{E000}-\x{F8FF}\x{FB29}\x{FD3E}-\x{FD3F}\x{FDFC}-\x{FDFD}
+\x{FE10}-\x{FE19}\x{FE30}-\x{FE6B}\x{FEFF}-\x{FF0F}\x{FF1A}-\x{FF20}
+\x{FF3B}-\x{FF40}\x{FF5B}-\x{FF65}\x{FFE0}-\x{FFFD}
+EOD;
+
+  /**
+   * Indicates that standard PHP (emulated) unicode support is being used.
+   */
+  const STATUS_SINGLEBYTE = 0;
+
+  /**
+   * Indicates that full unicode support with the PHP mbstring extension is
+   * being used.
+   */
+  const STATUS_MULTIBYTE = 1;
+
+  /**
+   * Indicates an error during check for PHP unicode support.
+   */
+  const STATUS_ERROR = -1;
+
+  /**
+   * Holds the multibyte capabilities of the current enviroment.
+   *
+   * @var int
+   */
+  public static $status = 0;
+
+  /**
+   * Checks for Unicode support in PHP and sets the proper settings if possible.
+   *
+   * Because of the need to be able to handle text in various encodings, we do
+   * not support mbstring function overloading. HTTP input/output conversion
+   * must be disabled for similar reasons.
+   *
+   * @return string
+   *   A string identifier of a failed multibyte extension check, if any.
+   *   Otherwise, an empty string.
+   */
+  public static function check() {
+    // Check for mbstring extension.
+    if (!function_exists('mb_strlen')) {
+      static::$status = static::STATUS_SINGLEBYTE;
+      return 'mb_strlen';
+    }
+
+    // Check mbstring configuration.
+    if (ini_get('mbstring.func_overload') != 0) {
+      static::$status = static::STATUS_ERROR;
+      return 'mbstring.func_overload';
+    }
+    if (ini_get('mbstring.encoding_translation') != 0) {
+      static::$status = static::STATUS_ERROR;
+      return 'mbstring.encoding_translation';
+    }
+    if (ini_get('mbstring.http_input') != 'pass') {
+      static::$status = static::STATUS_ERROR;
+      return 'mbstring.http_input';
+    }
+    if (ini_get('mbstring.http_output') != 'pass') {
+      static::$status = static::STATUS_ERROR;
+      return 'mbstring.http_output';
+    }
+
+    // Set appropriate configuration.
+    mb_internal_encoding('utf-8');
+    mb_language('uni');
+    static::$status = static::STATUS_MULTIBYTE;
+    return '';
+  }
+
+  /**
+   * Converts data to UTF-8.
+   *
+   * Requires the iconv, GNU recode or mbstring PHP extension.
+   *
+   * @param string $data
+   *   The data to be converted.
+   * @param string $encoding
+   *   The encoding that the data is in.
+   *
+   * @return string|bool
+   *   Converted data or FALSE.
+   */
+  public static function convertToUtf8($data, $encoding) {
+    if (function_exists('iconv')) {
+      return @iconv($encoding, 'utf-8', $data);
+    }
+    elseif (function_exists('mb_convert_encoding')) {
+      return @mb_convert_encoding($data, 'utf-8', $encoding);
+    }
+    elseif (function_exists('recode_string')) {
+      return @recode_string($encoding . '..utf-8', $data);
+    }
+    // Cannot convert.
+    return FALSE;
+  }
+
+  /**
+   * Truncates a UTF-8-encoded string safely to a number of bytes.
+   *
+   * If the end position is in the middle of a UTF-8 sequence, it scans backwards
+   * until the beginning of the byte sequence.
+   *
+   * Use this function whenever you want to chop off a string at an unsure
+   * location. On the other hand, if you're sure that you're splitting on a
+   * character boundary (e.g. after using strpos() or similar), you can safely
+   * use substr() instead.
+   *
+   * @param string $string
+   *   The string to truncate.
+   * @param int $len
+   *   An upper limit on the returned string length.
+   *
+   * @return string
+   *   The truncated string.
+   */
+  public static function truncateBytes($string, $len) {
+    if (strlen($string) <= $len) {
+      return $string;
+    }
+    if ((ord($string[$len]) < 0x80) || (ord($string[$len]) >= 0xC0)) {
+      return substr($string, 0, $len);
+    }
+    // Scan backwards to beginning of the byte sequence.
+    while (--$len >= 0 && ord($string[$len]) >= 0x80 && ord($string[$len]) < 0xC0);
+
+    return substr($string, 0, $len);
+  }
+
+  /**
+   * Decodes all HTML entities (including numerical ones) to regular UTF-8 bytes.
+   *
+   * Double-escaped entities will only be decoded once ("&amp;lt;" becomes "&lt;"
+   * , not "<"). Be careful when using this function, as decode_entities can
+   * revert previous sanitization efforts (&lt;script&gt; will become <script>).
+   *
+   * @param string $text
+   *   The text to decode entities in.
+   *
+   * @return string
+   *   The input $text, with all HTML entities decoded once.
+   */
+  public static function decodeEntities($text) {
+    return html_entity_decode($text, ENT_QUOTES, 'UTF-8');
+  }
+
+  /**
+   * Encodes MIME/HTTP headers that contain incorrectly encoded characters.
+   *
+   * For example, Unicode::mimeHeaderEncode('tést.txt') returns
+   * "=?UTF-8?B?dMOpc3QudHh0?=".
+   *
+   * See http://www.rfc-editor.org/rfc/rfc2047.txt for more information.
+   *
+   * Notes:
+   * - Only encode strings that contain non-ASCII characters.
+   * - We progressively cut-off a chunk with self::truncateBytes(). This ensures
+   *   each chunk starts and ends on a character boundary.
+   * - Using \n as the chunk separator may cause problems on some systems and
+   *   may have to be changed to \r\n or \r.
+   *
+   * @param string $string
+   *   The header to encode.
+   *
+   * @return string
+   *   The mime-encoded header.
+   */
+  public static function mimeHeaderEncode($string) {
+    if (preg_match('/[^\x20-\x7E]/', $string)) {
+      $chunk_size = 47; // floor((75 - strlen("=?UTF-8?B??=")) * 0.75);
+      $len = strlen($string);
+      $output = '';
+      while ($len > 0) {
+        $chunk = static::truncateBytes($string, $chunk_size);
+        $output .= ' =?UTF-8?B?' . base64_encode($chunk) . "?=\n";
+        $c = strlen($chunk);
+        $string = substr($string, $c);
+        $len -= $c;
+      }
+      return trim($output);
+    }
+    return $string;
+  }
+
+  /**
+   * Decodes MIME/HTTP encoded header values.
+   *
+   * @param string $header
+   *   The header to decode.
+   *
+   * @return string
+   *   The mime-decoded header.
+   */
+  public static function mimeHeaderDecode($header) {
+    // First step: encoded chunks followed by other encoded chunks (need to collapse whitespace)
+    $header = preg_replace_callback('/=\?([^?]+)\?(Q|B)\?([^?]+|\?(?!=))\?=\s+(?==\?)/', array(new static(), '_mimeHeaderDecode'), $header);
+    // Second step: remaining chunks (do not collapse whitespace)
+    return preg_replace_callback('/=\?([^?]+)\?(Q|B)\?([^?]+|\?(?!=))\?=/', array(new static(), '_mimeHeaderDecode'), $header);
+  }
+
+  /**
+   * Flips U+C0-U+DE to U+E0-U+FD and back.
+   *
+   * Can be used as a preg_replace_callback() callback.
+   *
+   * @param array $matches
+   *   The array of matches from preg_replace_callback().
+   *
+   * @return array
+   *   The Latin-1 version of the array of matches.
+   */
+  public static function caseFlip(array $matches) {
+    return $matches[0][0] . chr(ord($matches[0][1]) ^ 32);
+  }
+
+  /**
+   * Decodes encoded header.
+   *
+   * Can be used as a preg_replace_callback() callback.
+   *
+   * @param array $matches
+   *   The array of matches from preg_replace_callback().
+   *
+   * @return string
+   *   The mime-decoded string.
+   */
+  public static function _mimeHeaderDecode($matches) {
+    // Regexp groups:
+    // 1: Character set name
+    // 2: Escaping method (Q or B)
+    // 3: Encoded data
+    $data = ($matches[2] == 'B') ? base64_decode($matches[3]) : str_replace('_', ' ', quoted_printable_decode($matches[3]));
+    if (strtolower($matches[1]) != 'utf-8') {
+      $data = static::convertToUtf8($data, $matches[1]);
+    }
+    return $data;
+  }
+
+}
diff --git a/core/modules/search/search.module b/core/modules/search/search.module
index 6dd68d9..15b8935 100644
--- a/core/modules/search/search.module
+++ b/core/modules/search/search.module
@@ -6,6 +6,7 @@
  */
 
 use Drupal\Core\Entity\EntityInterface;
+use Drupal\Component\Utility\Unicode;
 
 /**
  * Matches all 'N' Unicode character classes (numbers)
@@ -447,7 +448,7 @@ function search_simplify($text, $langcode = NULL) {
 
   // With the exception of the rules above, we consider all punctuation,
   // marks, spacers, etc, to be a word boundary.
-  $text = preg_replace('/[' . PREG_CLASS_UNICODE_WORD_BOUNDARY . ']+/u', ' ', $text);
+  $text = preg_replace('/[' . Unicode::PREG_CLASS_WORD_BOUNDARY . ']+/u', ' ', $text);
 
   // Truncate everything to 50 characters.
   $words = explode(' ', $text);
@@ -1102,7 +1103,7 @@ function search_data($keys, $module, $conditions = NULL) {
  */
 function search_excerpt($keys, $text, $langcode = NULL) {
   // We highlight around non-indexable or CJK characters.
-  $boundary = '(?:(?<=[' . PREG_CLASS_UNICODE_WORD_BOUNDARY . PREG_CLASS_CJK . '])|(?=[' . PREG_CLASS_UNICODE_WORD_BOUNDARY . PREG_CLASS_CJK . ']))';
+  $boundary = '(?:(?<=[' . Unicode::PREG_CLASS_WORD_BOUNDARY . PREG_CLASS_CJK . '])|(?=[' . PREG_CLASS_UNICODE_WORD_BOUNDARY . PREG_CLASS_CJK . ']))';
 
   // Extract positive keywords and phrases
   preg_match_all('/ ("([^"]+)"|(?!OR)([^" ]+))/', ' ' . $keys, $matches);
diff --git a/core/modules/system/lib/Drupal/system/Tests/System/UnicodeUnitTest.php b/core/modules/system/lib/Drupal/system/Tests/System/UnicodeUnitTest.php
index 58bef10..052694f 100644
--- a/core/modules/system/lib/Drupal/system/Tests/System/UnicodeUnitTest.php
+++ b/core/modules/system/lib/Drupal/system/Tests/System/UnicodeUnitTest.php
@@ -8,6 +8,7 @@
 namespace Drupal\system\Tests\System;
 
 use Drupal\simpletest\UnitTestBase;
+use Drupal\Component\Utility\Unicode;
 
 /**
  * Test unicode handling features implemented in unicode.inc.
@@ -33,15 +34,13 @@ public static function getInfo() {
    * Test full unicode features implemented using the mbstring extension.
    */
   function testMbStringUnicode() {
-    global $multibyte;
-
     // mbstring was not detected on this installation, there is no way to test
     // multibyte features. Treat that as an exception.
-    if ($multibyte == UNICODE_SINGLEBYTE) {
+    if (Unicode::$status == Unicode::STATUS_SINGLEBYTE) {
       $this->error(t('Unable to test Multibyte features: mbstring extension was not detected.'));
     }
 
-    $multibyte = UNICODE_MULTIBYTE;
+    $multibyte = Unicode::STATUS_MULTIBYTE;
 
     $this->extendedMode = TRUE;
     $this->pass(t('Testing in mbstring mode'));
@@ -60,7 +59,7 @@ function testMbStringUnicode() {
   function testEmulatedUnicode() {
     global $multibyte;
 
-    $multibyte = UNICODE_SINGLEBYTE;
+    $multibyte = Unicode::STATUS_SINGLEBYTE;
 
     $this->extendedMode = FALSE;
 
diff --git a/core/modules/views/lib/Drupal/views/Plugin/views/HandlerBase.php b/core/modules/views/lib/Drupal/views/Plugin/views/HandlerBase.php
index 3b88f06..bb1223d 100644
--- a/core/modules/views/lib/Drupal/views/Plugin/views/HandlerBase.php
+++ b/core/modules/views/lib/Drupal/views/Plugin/views/HandlerBase.php
@@ -7,6 +7,7 @@
 
 namespace Drupal\views\Plugin\views;
 
+use Drupal\Component\Utility\Unicode;
 use Drupal\views\Plugin\views\display\DisplayPluginBase;
 use Drupal\views\Plugin\views\PluginBase;
 use Drupal\views\ViewExecutable;
@@ -254,7 +255,7 @@ protected function caseTransform($string, $option) {
       case 'ucfirst':
         return drupal_strtoupper(drupal_substr($string, 0, 1)) . drupal_substr($string, 1);
       case 'ucwords':
-        if ($multibyte == UNICODE_MULTIBYTE) {
+        if ($multibyte == Unicode::STATUS_MULTIBYTE) {
           return mb_convert_case($string, MB_CASE_TITLE);
         }
         else {