diff --git a/aloha.module b/aloha.module
index 3e3eef9..6c28e4b 100644
--- a/aloha.module
+++ b/aloha.module
@@ -35,6 +35,18 @@ function aloha_menu() {
 }
 
 /**
+ * Implements hook_editor_info().
+ */
+function aloha_editor_info() {
+  $editors['aloha'] = array(
+    'label' => t('Aloha'),
+    'library' => array('aloha', 'aloha-for-textareas'),
+    'js settings callback' => 'aloha_add_format_settings',
+  );
+  return $editors;
+}
+
+/**
  * Implements hook_library_info().
  */
 function aloha_library_info() {
@@ -222,6 +234,7 @@ function aloha_library_info() {
           'plugins' => array('load' => array('common/contenthandler')),
           'contentHandler' => array(
             'allows' => array('elements' => array(), 'attributes' => array()),
+            'handler' => array('sanitize' => array()),
           ),
         ))),
       ),
@@ -411,79 +424,6 @@ function aloha_library_info() {
 }
 
 /**
- * Implements hook_element_info_alter().
- */
-function aloha_element_info_alter(&$types) {
-  $types['text_format']['#pre_render'][] = 'aloha_pre_render_text_format';
-}
-
-/**
- * Render API callback: processes a text format widget to load and attach Aloha
- * Editor.
- *
- * Uses the element's #id as reference to attach Aloha Editor.
- */
-function aloha_pre_render_text_format($element) {
-  // filter_process_format() copies properties to the expanded 'value' child
-  // element. Skip this text format widget, if it contains no 'format' or when
-  // the current user does not have access to edit the value.
-  if (!isset($element['format']) || !empty($element['value']['#disabled'])) {
-    return $element;
-  }
-  // Allow modules to programmatically enforce no client-side editor by setting
-  // the #wysiwyg property to FALSE.
-  if (isset($element['#wysiwyg']) && !$element['#wysiwyg']) {
-    return $element;
-  }
-
-  $format_field = &$element['format'];
-  $field = &$element['value'];
-
-  // Use a hidden element for a single text format.
-  if (!$format_field['format']['#access']) {
-    $format_field['aloha'] = array(
-      '#type' => 'hidden',
-      '#name' => $format_field['format']['#name'],
-      '#value' => $field['#format'],
-      '#attributes' => array(
-        'id' => $format_field['format']['#id'],
-        'class' => array('aloha-formatselector-for-textarea'),
-      ),
-      '#attached' => array(
-        'library' => array(
-          array('aloha', 'aloha-for-textareas'),
-        ),
-        'js' => array(
-          array(
-            'type' => 'setting',
-            'data' => array('aloha' => array('textareas' => array(
-              $format_field['format']['#id'] => $field['#id'],
-            ))),
-          ),
-        ),
-        'aloha_add_format_settings' => array(
-          array()
-        ),
-      ),
-    );
-  }
-  // Otherwise, attach to text format selector.
-  else {
-    $format_field['format']['#attributes']['class'][] = 'aloha-formatselector-for-textarea';
-    $format_field['format']['#attached']['library'][] = array('aloha', 'aloha-for-textareas');
-    $format_field['format']['#attached']['js'][] = array(
-      'type' => 'setting',
-      'data' => array('aloha' => array('textareas' => array(
-        $format_field['format']['#id'] => $field['#id'],
-      ))),
-    );
-    $format_field['format']['#attached']['aloha_add_format_settings'][] = array();
-  }
-
-  return $element;
-}
-
-/**
  * Implements hook_filter_format_update().
  */
 function aloha_filter_format_update($format) {
@@ -491,32 +431,6 @@ function aloha_filter_format_update($format) {
 }
 
 /**
- * Get a list of HTML tags and attributes that are allowed by a given text
- * format, by performing black-box testing.
- *
- * @param  string $format_id
- *   A text format ID.
- * @return array
- *   An array of which the keys list all allowed tags and the corresponding
- *   values list the allowed attributes. An empty array as value means no
- *   attributes are allowed, array('*') means all attributes are allowed. In
- *   other cases, it's an enumeration of the allowed attributes, plus "data-" if
- *   any data- attribute is allowed.
- */
-function aloha_get_allowed_html_by_format($format_id) {
-  $cache_id = 'aloha-allowed-html:' . $format_id;
-  if ($cached = cache()->get($cache_id)) {
-    return $cached->data;
-  }
-
-  module_load_include('inc', 'aloha', 'includes/format');
-  $allowed_html = _aloha_calculate_allowed_html($format_id);
-  cache()->set($cache_id, $allowed_html);
-
-  return $allowed_html;
-}
-
-/**
  * Check the compatibility of Aloha Editor with a given text format.
  *
  * Aloha Editor can only work if the br and p tags are allowed by the text
@@ -560,132 +474,124 @@ function aloha_check_format_compatibility($format_id) {
 }
 
 /**
- * Adds Drupal.settings.aloha.formats and Aloha.settings.plugins.drupal. Ensures
- * Aloha Editor has the metadata to deal with formats.
+ * Filter JS settings callback; Add Aloha settings to the page for a format.
  *
- * @todo refactor; how to make the mapping of Aloha cleaner?
+ * @param $formats
+ *   The filter formats for which Aloha is adding its settings.
  * @todo revisit mapping when this Aloha issue is solved:
  *       https://github.com/alohaeditor/Aloha-Editor/issues/794
  */
-function aloha_add_format_settings() {
-  $format_settings_added = &drupal_static(__FUNCTION__, FALSE);
-
-  if (!$format_settings_added) {
-    $plugins = array('format', 'list', 'link', 'cite', 'align', 'image');
-    // Mapping from HTML element to Aloha Editor plug-in.
-    $tag_mapping = array(
-      'a' => 'link',
-      // Drupal does not approve <b>.
-      'b' => FALSE,
-      'blockquote' => 'cite',
-      'br' => 'format',
-      'cite' => 'cite',
-      'code' => 'format',
-      'em' => 'format',
-      'h1' => 'format',
-      'h2' => 'format',
-      'h3' => 'format',
-      'h4' => 'format',
-      'h5' => 'format',
-      'h6' => 'format',
-      // Drupal does not approve <i>.
-      'i' => FALSE,
-      'img' => 'image',
-      'li' => 'list',
-      'ol' => 'list',
-      'p' => 'format',
-      'q' => 'cite',
-      'pre' => 'format',
-      's' => 'format',
-      'strong' => 'format',
-      'sub' => 'format',
-      'sup' => 'format',
-      'u' => 'format',
-      'ul' => 'list',
-      'u' => 'format',
-    );
-    // Special cases.
-    $tag_mapping['removeFormat'] = 'format';
-    $attr_mapping = array(
-      'p' => array('style' => array(array('align', array('left', 'right', 'center', 'justify')))),
-    );
-
-    global $user;
-    $formats = filter_formats($user);
-    $settings['formats'] = array();
-
-    // Gather all necessary metadata for each format available to the current
-    // user.
-    foreach (array_keys($formats) as $format_id) {
-      $class = 'text-format-' . drupal_html_class($format_id);
-      $allowed_html = aloha_get_allowed_html_by_format($format_id);
+function aloha_add_format_settings($format, $filters, $existing_settings) {
+  $plugins = array('format', 'list', 'link', 'cite', 'align', 'image');
+  // Mapping from HTML element to Aloha Editor plug-in.
+  $tag_mapping = array(
+    'a' => 'link',
+    // Drupal does not approve <b>.
+    'b' => FALSE,
+    'blockquote' => 'cite',
+    'br' => 'format',
+    'cite' => 'cite',
+    'code' => 'format',
+    'em' => 'format',
+    'h1' => 'format',
+    'h2' => 'format',
+    'h3' => 'format',
+    'h4' => 'format',
+    'h5' => 'format',
+    'h6' => 'format',
+    // Drupal does not approve <i>.
+    'i' => FALSE,
+    'img' => 'image',
+    'li' => 'list',
+    'ol' => 'list',
+    'p' => 'format',
+    'q' => 'cite',
+    'pre' => 'format',
+    's' => 'format',
+    'strong' => 'format',
+    'sub' => 'format',
+    'sup' => 'format',
+    'u' => 'format',
+    'ul' => 'list',
+    'u' => 'format',
+  );
+  // Special cases.
+  $tag_mapping['removeFormat'] = 'format';
+  $attr_mapping = array(
+    'p' => array('style' => array(array('align', array('left', 'right', 'center', 'justify')))),
+  );
 
-      // Let drupal.aloha.js know which text formats are compatible and which
-      // class name should be set on the editable.
-      $settings['formats'][$format_id] = array(
-        'id' => $format_id,
-        // Only enable Aloha Editor if it is compatible with the text format.
-        'status' => aloha_check_format_compatibility($format_id),
-        // The class that will be set on the editable whenever this text format
-        // is active.
-        'className' => $class,
-      );
+  $format_name = $format->format;
+  $allowed_tags = aloha_get_allowed_html_by_format($format_name);
 
-      // Let the relevant Aloha Editor plug-ins know which HTML tags are
-      // allowed by this text format. Aloha Editor will only show the buttons
-      // for the allowed HTML tags.
-      // However, by default, explicitly disallow plug-ins from using defaults
-      // by setting an empty array.
-      foreach ($plugins as $plugin) {
-        $settings['settings']['plugins'][$plugin]['editables']['.' . $class] = array();
+  // Let the relevant Aloha Editor plug-ins know which HTML tags are
+  // allowed by this text format. Aloha Editor will only show the buttons
+  // for the allowed HTML tags.
+  // However, by default, explicitly disallow plug-ins from using defaults
+  // by setting an empty array.
+  foreach ($plugins as $plugin) {
+    $settings['plugins'][$plugin] = array();
+  }
+  $tags = array_keys($allowed_tags);
+  foreach ($tags as $tag) {
+    if (!isset($tag_mapping[$tag])) {
+      continue;
+    }
+    $plugin = $tag_mapping[$tag];
+    if ($plugin === FALSE) {
+      continue;
+    }
+    $settings['plugins'][$plugin][] = $tag;
+    // For some, there also exists an attribute mapping.
+    if (isset($attr_mapping[$tag])) {
+      $attrs = array_keys($attr_mapping[$tag]);
+      $allowed_attrs = $allowed_tags[$tag];
+      if ($format_name == 'filtered_html') {
+        $allowed_attrs = array();
       }
-      $tags = array_keys($allowed_html);
-      foreach ($tags as $tag) {
-        if (!isset($tag_mapping[$tag])) {
-          continue;
-        }
-        $plugin = $tag_mapping[$tag];
-        if ($plugin === FALSE) {
-          continue;
-        }
-        $settings['settings']['plugins'][$plugin]['editables']['.' . $class][] = $tag;
-        // For some, there also exists an attribute mapping.
-        if (isset($attr_mapping[$tag])) {
-          $attrs = array_keys($attr_mapping[$tag]);
-          $allowed_attrs = $allowed_html[$tag];
-          if ($format_id == 'filtered_html') {
-          $allowed_attrs = array();
-        }
-          if ($allowed_attrs === array('*')) {
-            $allowed_attrs = $attrs;
-          }
-          foreach ($attrs as $attr) {
-            if (in_array($attr, $allowed_attrs)) {
-              foreach ($attr_mapping[$tag][$attr] as $config_for_plugin) {
-                list($plugin, $config) = $config_for_plugin;
-                $settings['settings']['plugins'][$plugin]['editables']['.' . $class] = $config;
-              }
-            }
-          }
-        }
+      if ($allowed_attrs === array('*')) {
+        $allowed_attrs = $attrs;
       }
-
-      // Let Aloha Editor's "sanitize" content handler know which HTML tags and
-      // attributes are allowed by this text format. Aloha Editor will then
-      // ensure that when pasting content, nothing in the pasted content that is
-      // disallowed will continue to exist.
-      foreach ($allowed_html as $tag => $attributes) {
-        $settings['settings']['contentHandler']['handler']['sanitize']['.' . $class]['elements'][] = $tag;
-        if ($attributes !== array('*')) {
-          $settings['settings']['contentHandler']['handler']['sanitize']['.' . $class]['attributes'][$tag] = $attributes;
+      foreach ($attrs as $attr) {
+        if (in_array($attr, $allowed_attrs)) {
+          foreach ($attr_mapping[$tag][$attr] as $config_for_plugin) {
+            list($plugin, $config) = $config_for_plugin;
+            $settings['plugins'][$plugin] = $config;
+          }
         }
       }
     }
+  }
+  $settings['allowedTags'] = $allowed_tags;
+
+  return $settings;
+}
 
-    drupal_add_js(array('aloha' => $settings), array('type' => 'setting'));
 
-    $format_settings_added = TRUE;
+/**
+ * Get a list of HTML tags and attributes that are allowed by a given text
+ * format, by performing black-box testing.
+ *
+ * @param  string $format_name
+ *   A text format name.
+ * @return array
+ *   An array of which the keys list all allowed tags and the corresponding
+ *   values list the allowed attributes. An empty array as value means no
+ *   attributes are allowed, array('*') means all attributes are allowed. In
+ *   other cases, it's an enumeration of the allowed attributes, plus "data-" if
+ *   any data- attribute is allowed.
+ */
+function aloha_get_allowed_html_by_format($format_name) {
+  $cache_id = 'aloha-allowed-tags:' . $format_name;
+  if ($cached = cache()->get($cache_id)) {
+    return $cached->data;
   }
+
+  module_load_include('inc', 'aloha', 'includes/format');
+  $allowed_tags = _aloha_calculate_allowed_tags($format_name);
+  cache()->set($cache_id, $allowed_tags);
+
+  return $allowed_tags;
 }
 
 /**
diff --git a/includes/format.inc b/includes/format.inc
index ddf1146..2ed9764 100644
--- a/includes/format.inc
+++ b/includes/format.inc
@@ -1,153 +1,216 @@
 <?php
 
 /**
- * @file
- * Aloha Editor Repository API page callbacks.
- */
-
-/**
- * Provides the test cases used by _aloha_calculate_allowed_html().
- */
-function _aloha_allowed_html_tests() {
-  return array(
-    array(
-      'tag' => 'p',
-      // For a single <p> that would be stripped, filter_autop would generate
-      // it again, making it impossible to detect that filter_html actually
-      // stripped it away. Hence we need to use two adjacent <p> tags.
-      'testcase' => '<p>Hello, world!</p><p>This is Drupal!</p>',
-      'attributes' => array(
-        'prefix' => '<p ',
-        'suffix' => '>Hello, world!</p>',
-        'names' => array('dir'),
-      ),
-    ),
-    array(
-      'tag' => 'blockquote',
-      'testcase' => '<blockquote>Veni, vidi, vici.</blockquote>',
-      'attributes' => array(
-        'prefix' => '<blockquote ',
-        'suffix' => '>Veni, vidi, vici!</blockquote>',
-        'names' => array('cite'),
-      ),
-    ),
-    array('tag' => 'h1', 'testcase' => '<h1>heading 1</h1>'),
-    array('tag' => 'h2', 'testcase' => '<h2>heading 2</h2>'),
-    array('tag' => 'h3', 'testcase' => '<h3>heading 3</h3>'),
-    array('tag' => 'h4', 'testcase' => '<h4>heading 4</h4>'),
-    array('tag' => 'h5', 'testcase' => '<h5>heading 5</h5>'),
-    array('tag' => 'h6', 'testcase' => '<h6>heading 6</h6>'),
-    array('tag' => 'ul', 'testcase' => '<ul><li>A</li><li>B</li></ul>'),
-    array('tag' => 'ol', 'testcase' => '<ol><li>A</li><li>B</li></ol>'),
-    array('tag' => 'li', 'testcase' => '<li>A</li>'),
-    array('tag' => 'pre', 'testcase' => '<pre>preformatted text</pre>'),
-    // Text-level elements. (Should all be wrapped in <p> tags.)
-    array(
-      'tag' => 'a',
-      'testcase' => '<p><a>hyperlink</a></p>',
-      'attributes' => array(
-        'prefix' => '<p><a ',
-        'suffix' => '>hyperlink</a></p>',
-        'names' => array('href', 'target', 'rel', 'media'),
-      ),
-    ),
-    array('tag' => 'em', 'testcase' => '<p><em>emphasized</em></p>'),
-    array('tag' => 'strong', 'testcase' => '<p><strong>strong</strong></p>'),
-    array('tag' => 'i', 'testcase' => '<p><i>italicized</i></p>'),
-    array('tag' => 'b', 'testcase' => '<p><b>bold</b></p>'),
-    array('tag' => 'u', 'testcase' => '<p><u>underlined</u></p>'),
-    array('tag' => 'cite', 'testcase' => '<p><cite>He</cite> said "WOW, Drupal rocks!"</p>'),
-    array('tag' => 'q', 'testcase' => '<p>He said <q>"WOW, Drupal rocks!"</q></p>'),
-    array('tag' => 'br', 'testcase' => '<p>First line<br />Second line</p>'),
-    array(
-      'tag' => 'code',
-      'testcase' => '<p><code>Hello, world!</code></p>',
-      'attributes' => array(
-        'prefix' => '<p><code ',
-        'suffix' => '>Hello, world!</code></p>',
-        'names' => array('lang'),
-      ),
-    ),
-    array(
-      'tag' => 'img',
-      'testcase' => '<p><img /></p>',
-      'attributes' => array(
-        'prefix' => '<p><img ',
-        'suffix' => ' /></p>',
-        'names' => array('src', 'alt', 'title')
-      ),
-    ),
-  );
-}
-
-/**
- * Calculates the allowed HTML tags.
- *
- * @param  string $format_id
- *   A text format ID.
- * @return
- *   @see aloha_get_allowed_html_by_format()
+ * Returns list of allowed tags for a particular format. Do not call directly.
  *
- * @todo  Refactor.
- * @todo  Unit tests. Start from http://drupal.org/node/1782838#comment-6562024.
+ * @see filter_allowed_tag_list().
  */
-function _aloha_calculate_allowed_html($format_id) {
-  // For testing whether any attribute is allowed.
-  $any = 'thisIsAnExtremelyUnlikelyToExistAttributeName';
-
-  // For testing whether data- attributes are allowed.
-  $data = 'data-' . chr(mt_rand(65, 90));
-
-  // Helper function to assert the filtered text still contains the original.
-  $assert_match = function ($original, $format_id) {
-    $filtered = check_markup($original, $format_id);
-    $result = preg_replace("/>\s+</", "><", $filtered);
-    return stripos($result, $original) !== FALSE;
-  };
-
-  // Run all the above tagtests to determine which tags and attributes are
-  // allowed in the given text format.
-  $allowed_html = array_reduce(
-    _aloha_allowed_html_tests(),
-    function($result, $tagtest) use ($assert_match, $format_id, $any, $data) {
-      $tag = $tagtest['tag'];
-      if ($assert_match($tagtest['testcase'], $format_id)) {
-        $result[$tag] = array();
+function _aloha_calculate_allowed_tags($format_name) {
+  $allowed_tags = array();
+  $tag_information = _aloha_tag_information();
 
-        // Break early if there are no attributes to test.
-        if (!isset($tagtest['attributes'])) {
-          return $result;
-        }
+  // Determine which tags and attributes are allowed in the given text format.
+  foreach ($tag_information as $tag_name => $tag_info) {
+    $test_case = _aloha_tag_test_case($tag_name, $tag_info);
+    $test_result = check_markup($test_case, $format_name, NULL, FALSE, array(FILTER_TYPE_MARKUP_LANGUAGE));
+    if (strcasecmp($test_result, $test_case) === 0) {
+      // The tag is allowed.
+      $allowed_tags[$tag_name] = array();
 
-        // Anonymous function to generate attribute test cases.
-        $generate_attr_testcase = function($attr) use ($tagtest) {
-          $case = '';
-          $case .= $tagtest['attributes']['prefix'];
-          $case .= $attr . '="' . $attr . ' attribute test"';
-          $case .= $tagtest['attributes']['suffix'];
-          return $case;
-        };
+      // Make sure required attributes are included.
+      if (isset($tag_test['required'])) {
+        $allowed_tags[$tag_name] = array_keys($tag_test['required']);
+      }
 
-        // The tag test passed, then we can also do the attribute tests. First,
-        // check if any attribute is allowed, if that's not the case, then
-        // figure out which specific attributes are allowed.
-        if ($assert_match($generate_attr_testcase($any), $format_id)) {
-          $result[$tag][] = '*';
-        }
-        else {
-          $attrs = array_merge(array($data), $tagtest['attributes']['names']);
-          foreach ($attrs as $attr) {
-            if ($assert_match($generate_attr_testcase($attr), $format_id)) {
-              $result[$tag][] = ($attr === $data) ? 'data-' : $attr;
-            }
+      // Check which particular attributes are allowed.
+      list($tag_prefix, $tag_suffix1, $tag_suffix2) = preg_split('/([ >])/', $test_case, 2, PREG_SPLIT_DELIM_CAPTURE);
+      $tag_suffix = $tag_suffix1 . $tag_suffix2;
+      if (isset($tag_test['optional'])) {
+        foreach ($tag_test['optional'] as $attribute => $attribute_value) {
+          $attribute_string = $attribute . (isset($attribute_value) ? '="' . $attribute_value . '"' : '');
+          $attribute_testcase = $tag_prefix . " $attribute_string" . $tag_suffix;
+          $test_result = check_markup($attribute_testcase, $format_name, NULL, FALSE, array(FILTER_TYPE_MARKUP_LANGUAGE));
+          if (strcasecmp($test_result, $attribute_testcase) === 0) {
+            $allowed_tags[$tag_name][] = $attribute;
           }
         }
       }
 
-      return $result;
-    },
-    array()
+      // Check for data-* attributes
+      $data = 'data-extremelyUnlikelyDataAttribute';
+      $attribute_testcase = $tag_prefix . ' ' . $data . '=""' . $tag_suffix;
+      $test_result = check_markup($attribute_testcase, $format_name, NULL, FALSE, array(FILTER_TYPE_MARKUP_LANGUAGE));
+      if (strcasecmp($test_result, $attribute_testcase) === 0) {
+        $allowed_tags[$tag_name][] = 'data-';
+      }
+    }
+  }
+
+  return $allowed_tags;
+}
+
+/**
+ * Provides the test cases used by _filter_calculate_allowed_tags().
+ *
+ * This set of tags does not include:
+ *   - Form elements such as <input>, <button>, or <select>.
+ *   - Page structure elements such as <body> or <head>.
+ *   - Table elements such as <table>, <td>, or <tr>.
+ *   - Image map elements such as <area> or <map>.
+ */
+function _aloha_tag_information() {
+  $tag_info = array(
+    // Global attributes.
+    '@' => array(
+      'optional' => array('accesskey' => '', 'class' => '', 'contenteditable' => 'true', 'contextmenu' => '', 'dir' => 'rtl', 'draggable' => 'true', 'dropzone' => 'copy', 'hidden' => 'hidden', 'id' => '', 'lang' => '', 'spellcheck' => 'true', 'style' => '', 'tabindex' => '1', 'title' => ''),
+    ),
+    'a' => array(
+      'required' => array('href' => '#'),
+      'optional' => array('hreflang' => '', 'media' => '', 'name' => '', 'rel' => '', 'target' => '_blank', 'type' => ''),
+    ),
+    'abbr' => array(),
+    'address' => array(),
+    'article' => array(),
+    'aside' => array(),
+    'audio' => array(
+      'optional' => array('autoplay' => 'true', 'controls' => 'true', 'loop' => 'true', 'preload' => 'true', 'src' => 'true'),
+      'dependencies' => array('source'),
+    ),
+    'b' => array(),
+    'bdi' => array(),
+    'bdo' => array(),
+    'blockquote' => array(
+      'optional' => array('cite' => ''),
+    ),
+    'br' => array(
+      'self_closing' => TRUE,
+    ),
+    'caption' => array(),
+    'cite' => array(),
+    'code' => array(
+      'optional' => array('lang' => ''),
+    ),
+    'dd' => array(),
+    'del' => array(
+      'optional' => array('cite' => '', 'datetime' => ''),
+    ),
+    'dfn' => array(),
+    'div' => array(),
+    'dl' => array(
+      'dependencies' => array('dt', 'dd'),
+    ),
+    'dt' => array(),
+    'em' => array(),
+    'footer' => array(),
+    'figcaption' => array(),
+    'figure' => array(),
+    'header' => array(),
+    'h1' => array(),
+    'h2' => array(),
+    'h3' => array(),
+    'h4' => array(),
+    'h5' => array(),
+    'h6' => array(),
+    'hr' => array(),
+    'i' => array(),
+    'iframe' => array(
+      'optional' => array('frameborder' => '1', 'height' => '', 'name' => '', 'sandbox' => '', 'scrolling' => 'yes', 'seamless' => 'true', 'src' => '', 'srcdoc' => '', 'width' => ''),
+    ),
+    'img' => array(
+      'self_closing' => TRUE,
+      'required' => array('src' => '#', 'alt' => ''),
+      'optional' => array('title' => '', 'height' => '', 'width' => ''),
+    ),
+    'ins' => array(
+      'optional' => array('cite' => '', 'datetime' => ''),
+    ),
+    'kbd' => array(),
+    'li' => array(
+      'optional' => array('value' => ''),
+    ),
+    'mark' => array(),
+    'nav' => array(),
+    'noscript' => array(),
+    'object' => array(
+      'optional' => array('data' => '', 'form' => '', 'height' => '', 'name' => '', 'type' => '', 'width' => ''),
+    ),
+    'ol' => array(
+      'dependencies' => array('li'),
+    ),
+    'p' => array(),
+    'param' => array(
+      'optional' => array('name' => '', 'type' => '', 'value' => ''),
+    ),
+    'pre' => array(),
+    'q' => array(
+      'optional' => array('cite' => ''),
+    ),
+    'rp' => array(),
+    'rt' => array(),
+    'ruby' => array(
+      'dependencies' => array('rt', 'rp'),
+    ),
+    's' => array(),
+    'samp' => array(),
+    'script' => array(
+      'optional' => array('async' => 'async', 'charset' => '', 'defer' => 'defer', 'src' => '', 'type' => ''),
+    ),
+    'small' => array(),
+    'source' => array(
+      'optional' => array('media' => '', 'src' => '', 'type' => ''),
+    ),
+    'span' => array(),
+    'strike' => array(),
+    'strong' => array(),
+    'sub' => array(),
+    'sup' => array(),
+    'time' => array(
+      'optional' => array('datetime' => '', 'pubdate' => ''),
+    ),
+    'u' => array(),
+    'ul' => array(
+      'dependencies' => array('li'),
+    ),
+    'var' => array(),
+    'video' => array(
+      'optional' => array('src' => '', 'crossorigin' => '', 'poster' => '', 'preload' => '', 'autoplay' => '', 'mediagroup' => '', 'loop' => '', 'muted' => '', 'controls' => '', 'width' => '', 'height' => ''),
+      'dependencies' => array('source'),
+    ),
+    'wbr' => array(
+      'self_closing' => TRUE,
+    ),
   );
+  drupal_alter('aloha_tag_information', $tag_info);
+  return $tag_info;
+}
 
-  return $allowed_html;
+/**
+ * Construct a string example of an HTML tag given its tag information.
+ */
+function _aloha_tag_test_case($tag_name, $tag_info) {
+  // Check if the markup is unchanged after running the test.
+  $test_case = '<' . $tag_name;
+  if (!empty($tag_info['required'])) {
+    $test_case .= (string) new Drupal\Core\Template\Attribute($tag_info['required']);
+  }
+  if (empty($tag_info['self_closing'])) {
+    $test_case .= '>';
+    if (empty($tag_info['dependencies'])) {
+      $test_case .= 'test';
+    }
+    else {
+      foreach ($tag_info['dependencies'] as $dependency) {
+        $test_case .= '<' . $dependency . '>';
+      }
+      $test_case .= 'test';
+      foreach (array_reverse($tag_info['dependencies']) as $dependency) {
+        $test_case .= '</' . $dependency . '>';
+      }
+    }
+    $test_case .= '</' . $tag_name . '>';
+  }
+  else {
+    $test_case .= ' />';
+  }
+  return $test_case;
 }
diff --git a/js/drupal.aloha.js b/js/drupal.aloha.js
index c159ae3..be39a83 100644
--- a/js/drupal.aloha.js
+++ b/js/drupal.aloha.js
@@ -92,7 +92,30 @@ Drupal.aloha = {
     var $alohaEditable = Drupal.aloha._getAlohaEditable($editable);
     var id = $alohaEditable.attr('id');
 
-    Drupal.aloha._setFormatClass($alohaEditable, format.className);
+    // Let Aloha Editor's "sanitize" content handler know which HTML tags and
+    // attributes are allowed by this format. Aloha Editor will then ensure that
+    // when pasting content, nothing in the pasted content that is disallowed
+    // will continue to exist.
+    for (var plugin in format.editorSettings.plugins) {
+      if (format.editorSettings.plugins.hasOwnProperty(plugin)) {
+        if (!Aloha.settings.plugins[plugin]) {
+          Aloha.settings.plugins[plugin] = { config: {} };
+        }
+        Aloha.settings.plugins[plugin]['config'] = format.editorSettings.plugins[plugin];
+      }
+    }
+    Aloha.settings.contentHandler.allows = {
+      elements: [],
+      attributes: {}
+    }
+    for (var tag in format.editorSettings.allowedTags) {
+      if (format.editorSettings.allowedTags.hasOwnProperty(tag)) {
+        Aloha.settings.contentHandler.allows.elements.push(tag);
+        if (format.editorSettings.allowedTags[tag].length) {
+          Aloha.settings.contentHandler.allows.attributes[tag] = format.editorSettings.allowedTags[tag];
+        }
+      }
+    }
 
     Aloha.jQuery('#' + id).aloha();
 
@@ -147,28 +170,6 @@ Drupal.aloha = {
   },
 
   /**
-   * Remove any previous format classes and set the one for the current format.
-   *
-   * @param $alohaEditable
-   *   The "Aloha" editable, typically a <div>, possibly a temporary one because
-   *   the "original" editable is a <textarea>.
-   * @param formatClassName
-   *   The class name for the current format.
-   */
-  _setFormatClass: function($alohaEditable, formatClassName) {
-    var formats = Drupal.settings.aloha.formats;
-    for (var format in formats) {
-      if (formats.hasOwnProperty(format)) {
-        $alohaEditable.removeClass(formats[format].className);
-      }
-    }
-
-    if (typeof formatClassName !== 'undefined') {
-      $alohaEditable.addClass(formatClassName);
-    }
-  },
-
-  /**
    * If no ID is set on this editable, then generate one.
    *
    * @param $editable
diff --git a/js/drupal.aloha.textarea.js b/js/drupal.aloha.textarea.js
index de30cab..3866a97 100644
--- a/js/drupal.aloha.textarea.js
+++ b/js/drupal.aloha.textarea.js
@@ -2,55 +2,24 @@
 
 "use strict";
 
-Drupal.behaviors.alohaTextareas = {
-  attach: function (context) {
-    var $context = $(context);
+Drupal.editors.aloha = {
+  attach: function (field, format) {
     Drupal.aloha.init(function () {
       var first = true;
-      $context.find('.aloha-formatselector-for-textarea').once('alohaTextareas', function () {
-        if (!this.id || typeof Drupal.settings.aloha.textareas[this.id] === 'undefined') {
-          return;
-        }
-        var $this = $(this);
-        var format = Drupal.settings.aloha.formats[this.value];
-        var field = Drupal.settings.aloha.textareas[this.id];
-        var $editable = $context.find('#' + field);
-        // Directly attach this editor, if the input format is enabled.
-        if (format.status) {
-          Drupal.aloha.attach($editable, format);
+      var $editable = $(field);
+      // Directly attach this editor, if the input format is enabled.
+      Drupal.aloha.attach($editable, format);
 
-          // Activate the first Aloha Editor.
-          if (first) {
-            Drupal.aloha.activate($editable);
-            first = false;
-          }
-        }
-
-        // React appropriately to changed input formats.
-        if ($this.is('select')) {
-          $this.bind('change.aloha', function () {
-            // NOTE: we cannot optimize this to *not* detach and reattach Aloha
-            // Editor; otherwise it would not pick up the changed
-            // data-allowed-tags attribute.
-            Drupal.aloha.detach($editable);
-            var format = Drupal.settings.aloha.formats[this.value];
-            if (format.status) {
-              Drupal.aloha.attach($editable, format);
-              Drupal.aloha.activate($editable);
-            }
-          });
-        }
-
-        // Detach Aloha Editor when the containing form is submitted.
-        $editable.parents('form').submit(function (event) {
-          // Do not detach if the event was cancelled.
-          if (event.isDefaultPrevented()) {
-            return;
-          }
-          Drupal.aloha.detach($editable);
-        });
-      });
+      // Activate the first Aloha Editor.
+      if (first) {
+        Drupal.aloha.activate($editable);
+        first = false;
+      }
     });
+  },
+  detach: function (field, format) {
+    var $editable = $(field);
+    Drupal.aloha.detach($editable);
   }
 };