diff --git a/docs/src/mkdocs.yml b/docs/src/mkdocs.yml
index cad951425..9a7a21b50 100644
--- a/docs/src/mkdocs.yml
+++ b/docs/src/mkdocs.yml
@@ -169,32 +169,30 @@ markdown_extensions:
   - pymdownx.tabbed:
       alternate_style: true
   - pymdownx.saneheaders:
-  - pymdownx.blocks:
-      blocks:
-        pymdownx.blocks.admonition:Admonition:
-          types:
-          - new
-          - settings
-          - note
-          - abstract
-          - info
-          - tip
-          - success
-          - question
-          - warning
-          - failure
-          - danger
-          - bug
-          - example
-          - quote
-        pymdownx.blocks.details:Details:
-        pymdownx.blocks.html:HTML:
-        pymdownx.blocks.definition:Definition:
-        pymdownx.blocks.tab:Tab:
-          alternate_style: True
-        tools.collapse_code:CollapseCode:
-          expand_text: ''
-          collapse_text: ''
+  - pymdownx.blocks.admonition:
+      types:
+      - new
+      - settings
+      - note
+      - abstract
+      - info
+      - tip
+      - success
+      - question
+      - warning
+      - failure
+      - danger
+      - bug
+      - example
+      - quote
+  - pymdownx.blocks.details:
+  - pymdownx.blocks.html:
+  - pymdownx.blocks.definition:
+  - pymdownx.blocks.tab:
+      alternate_style: True
+  - tools.collapse_code:
+      expand_text: ''
+      collapse_text: ''
 
 extra:
   social:
diff --git a/mkdocs.yml b/mkdocs.yml
index b2af77550..16396575f 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -169,32 +169,30 @@ markdown_extensions:
   - pymdownx.tabbed:
       alternate_style: true
   - pymdownx.saneheaders:
-  - pymdownx.blocks:
-      blocks:
-        pymdownx.blocks.admonition:Admonition:
-          types:
-          - new
-          - settings
-          - note
-          - abstract
-          - info
-          - tip
-          - success
-          - question
-          - warning
-          - failure
-          - danger
-          - bug
-          - example
-          - quote
-        pymdownx.blocks.details:Details:
-        pymdownx.blocks.html:HTML:
-        pymdownx.blocks.definition:Definition:
-        pymdownx.blocks.tab:Tab:
-          alternate_style: True
-        tools.collapse_code:CollapseCode:
-          expand_text: ''
-          collapse_text: ''
+  - pymdownx.blocks.admonition:
+      types:
+      - new
+      - settings
+      - note
+      - abstract
+      - info
+      - tip
+      - success
+      - question
+      - warning
+      - failure
+      - danger
+      - bug
+      - example
+      - quote
+  - pymdownx.blocks.details:
+  - pymdownx.blocks.html:
+  - pymdownx.blocks.definition:
+  - pymdownx.blocks.tab:
+      alternate_style: True
+  - tools.collapse_code:
+      expand_text: ''
+      collapse_text: ''
 
 extra:
   social:
diff --git a/pymdownx/blocks/__init__.py b/pymdownx/blocks/__init__.py
index 5a83152bc..5466b966b 100644
--- a/pymdownx/blocks/__init__.py
+++ b/pymdownx/blocks/__init__.py
@@ -7,7 +7,6 @@
 import re
 import yaml
 import textwrap
-import importlib
 
 # Fenced block placeholder for SuperFences
 FENCED_BLOCK_RE = re.compile(
@@ -120,22 +119,14 @@ def revert_fenced_code(md, blocks):
 class BlocksProcessor(BlockProcessor):
     """Generic block processor."""
 
-    def __init__(self, parser, md, config):
+    def __init__(self, parser, md):
         """Initialization."""
 
         self.md = md
 
-        blocks = config['blocks']
-
-        if not blocks:  # pragma: no cover
-            blocks = {}
-
         # The Block classes indexable by name
         self.blocks = {}
         self.config = {}
-        for blk, cfg in blocks.items():
-            self.register(blk, cfg if cfg is not None else {})
-
         self.empty_tags = set(['hr'])
         self.block_level_tags = set(md.block_level_elements.copy())
         self.block_level_tags.add('html')
@@ -168,35 +159,13 @@ def __init__(self, parser, md, config):
         self.end = RE_END
         self.yaml_line = RE_INDENT_YAML_LINE
 
-    def _import(self, plugin):
-        """Import the plugin."""
-
-        module_name, class_name = plugin.split(':', 1)
-        module = importlib.import_module(module_name)
-        return getattr(module, class_name)
-
     def register(self, b, config):
         """Register a block."""
 
-        if isinstance(b, str):
-            b = self._import(b)
-
         if b.NAME in self.blocks:
             raise ValueError('The block name {} is already registered!'.format(b.NAME))
         self.blocks[b.NAME] = b
-        self.config[b.NAME] = self.set_configs(b.CONFIG, config)
-        b.on_register(self, self.md, self.config.get(b.NAME, {}))
-
-    def set_configs(self, default, config):
-        """Set config for a block extension."""
-
-        d = {}
-        for key in default.keys():
-            if key in config:
-                d[key] = config[key]
-            else:
-                d[key] = default[key]
-        return d
+        self.config[b.NAME] = config
 
     def test(self, parent, block):
         """Test to see if we should process the block."""
@@ -444,26 +413,15 @@ def run(self, parent, blocks):
                     break
 
 
-class BlocksExtension(Extension):
+class BlocksMgrExtension(Extension):
     """Add generic Blocks extension."""
 
-    def __init__(self, *args, **kwargs):
-        """Initialize."""
-
-        self.config = {
-            'blocks': [{}, "Blocks extensions to load, if not defined, the default ones will be loaded."],
-        }
-
-        super().__init__(*args, **kwargs)
-
     def extendMarkdown(self, md):
         """Add Blocks to Markdown instance."""
 
         md.registerExtension(self)
         util.escape_chars(md, ['/'])
-
-        config = self.getConfigs()
-        self.extension = BlocksProcessor(md.parser, md, config)
+        self.extension = BlocksProcessor(md.parser, md)
         # We want to be right after list indentations are processed
         md.parser.blockprocessors.register(self.extension, "blocks", 89)
 
@@ -473,7 +431,25 @@ def reset(self):
         self.extension._reset()
 
 
-def makeExtension(*args, **kwargs):
-    """Return extension."""
+class BlocksExtension(Extension):
+    """Blocks Extension."""
+
+    def register_block_mgr(self, md):
+        """Add Blocks to Markdown instance."""
+
+        if 'blocks' not in  md.parser.blockprocessors:
+            ext = BlocksMgrExtension()
+            ext.extendMarkdown(md)
+            mgr = ext.extension
+        else:
+            mgr = md.parser.blockprocessors['blocks']
+        return mgr
+
+    def extendMarkdown(self, md):
+        """Extend markdown."""
+
+        mgr = self.register_block_mgr(md)
+        self.extendMarkdownBlocks(md, mgr)
 
-    return BlocksExtension(*args, **kwargs)
+    def extendMarkdownBlocks(self, md, blocks):
+        """Extend Markdown blocks."""
diff --git a/pymdownx/blocks/admonition.py b/pymdownx/blocks/admonition.py
index 8027eba4a..55110ad4e 100644
--- a/pymdownx/blocks/admonition.py
+++ b/pymdownx/blocks/admonition.py
@@ -1,6 +1,7 @@
 """Admonitions."""
 import xml.etree.ElementTree as etree
 from .block import Block, type_html_identifier
+from .. blocks import BlocksExtension
 import re
 
 RE_SEP = re.compile(r'[_-]+')
@@ -27,18 +28,6 @@ class Admonition(Block):
     OPTIONS = {
         'type': ['', type_html_identifier],
     }
-    CONFIG = {
-        "types": ['note', 'attention', 'caution', 'danger', 'error', 'tip', 'hint', 'warning']
-    }
-
-    @classmethod
-    def on_register(cls, blocks_extension, md, config):
-        """Handle registration event."""
-
-        # Generate an admonition subclass based on the given names.
-        for b in config.get('types', []):
-            subclass = RE_SEP.sub('', b.title())
-            blocks_extension.register(type(subclass, (Admonition,), {'OPTIONS': {}, 'NAME': b, 'CONFIG': {}}), {})
 
     def on_parse(self):
         """Handle on parse event."""
@@ -73,3 +62,35 @@ def on_create(self, parent):
             ad_title.text = title
 
         return el
+
+
+class AdmonitionExtension(BlocksExtension):
+    """Admonition Blocks Extension."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize."""
+
+        self.config = {
+            "types": [
+                ['note', 'attention', 'caution', 'danger', 'error', 'tip', 'hint', 'warning'],
+                "Generate Admonition block extensions for the given types."
+            ]
+        }
+
+        super().__init__(*args, **kwargs)
+
+    def extendMarkdownBlocks(self, md, blocks):
+        """Extend Markdown blocks."""
+
+        blocks.register(Admonition, self.getConfigs())
+
+        # Generate an admonition subclass based on the given names.
+        for b in self.getConfig('types', []):
+            subclass = RE_SEP.sub('', b.title())
+            blocks.register(type(subclass, (Admonition,), {'OPTIONS': {}, 'NAME': b, 'CONFIG': {}}), {})
+
+
+def makeExtension(*args, **kwargs):
+    """Return extension."""
+
+    return AdmonitionExtension(*args, **kwargs)
diff --git a/pymdownx/blocks/block.py b/pymdownx/blocks/block.py
index 305c8fcfa..d107ad548 100644
--- a/pymdownx/blocks/block.py
+++ b/pymdownx/blocks/block.py
@@ -296,10 +296,6 @@ def on_parse(self):
 
         return True
 
-    @classmethod
-    def on_register(cls, block_processor, md, config):
-        """Handle registration events."""
-
     @abstractmethod
     def on_create(self, parent):
         """Create the needed element and return it."""
diff --git a/pymdownx/blocks/definition.py b/pymdownx/blocks/definition.py
index 48a384fe5..8c10dad24 100644
--- a/pymdownx/blocks/definition.py
+++ b/pymdownx/blocks/definition.py
@@ -1,6 +1,7 @@
 """Definition."""
 import xml.etree.ElementTree as etree
 from .block import Block
+from ..blocks import BlocksExtension
 
 
 class Definition(Block):
@@ -47,3 +48,18 @@ def on_end(self, block):
 
         for el in remove:
             block.remove(el)
+
+
+class DefinitionExtension(BlocksExtension):
+    """Definition Blocks Extension."""
+
+    def extendMarkdownBlocks(self, md, blocks):
+        """Extend Markdown blocks."""
+
+        blocks.register(Definition, self.getConfigs())
+
+
+def makeExtension(*args, **kwargs):
+    """Return extension."""
+
+    return DefinitionExtension(*args, **kwargs)
diff --git a/pymdownx/blocks/details.py b/pymdownx/blocks/details.py
index 33f3feb57..ed6fde40a 100644
--- a/pymdownx/blocks/details.py
+++ b/pymdownx/blocks/details.py
@@ -1,6 +1,7 @@
 """Details."""
 import xml.etree.ElementTree as etree
 from .block import Block, type_boolean, type_html_identifier
+from ..blocks import BlocksExtension
 import re
 
 RE_SEP = re.compile(r'[_-]+')
@@ -35,17 +36,6 @@ class Details(Block):
         "types": []
     }
 
-    @classmethod
-    def on_register(cls, blocks_extension, md, config):
-        """Handle registration event."""
-
-        # Generate an admonition subclass based on the given names.
-        for b in config.get('types', []):
-            subclass = RE_SEP.sub('', b.title())
-            blocks_extension.register(
-                type(subclass, (Details,), {'OPTIONS': {'open': [False, type_boolean]}, 'NAME': b, 'CONFIG': {}}), {}
-            )
-
     def on_parse(self):
         """Handle on parse event."""
 
@@ -84,3 +74,37 @@ def on_create(self, parent):
             s.text = summary
 
         return el
+
+
+class DetailsExtension(BlocksExtension):
+    """Admonition Blocks Extension."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize."""
+
+        self.config = {
+            "types": [
+                [],
+                "Generate Admonition block extensions for the given types."
+            ]
+        }
+
+        super().__init__(*args, **kwargs)
+
+    def extendMarkdownBlocks(self, md, blocks):
+        """Extend Markdown blocks."""
+
+        blocks.register(Details, self.getConfigs())
+
+        # Generate an details subclass based on the given names.
+        for b in self.getConfig('types', []):
+            subclass = RE_SEP.sub('', b.title())
+            blocks.register(
+                type(subclass, (Details,), {'OPTIONS': {'open': [False, type_boolean]}, 'NAME': b, 'CONFIG': {}}), {}
+            )
+
+
+def makeExtension(*args, **kwargs):
+    """Return extension."""
+
+    return DetailsExtension(*args, **kwargs)
diff --git a/pymdownx/blocks/html.py b/pymdownx/blocks/html.py
index 6e66c22b3..debf80589 100644
--- a/pymdownx/blocks/html.py
+++ b/pymdownx/blocks/html.py
@@ -1,6 +1,7 @@
 """HTML."""
 import xml.etree.ElementTree as etree
 from .block import Block, type_string_in
+from ..blocks import BlocksExtension
 import re
 
 # Sub-patterns parts
@@ -153,3 +154,18 @@ def on_create(self, parent):
 
         # Create element
         return etree.SubElement(parent, self.tag.lower(), self.attr)
+
+
+class HTMLExtension(BlocksExtension):
+    """HTML Blocks Extension."""
+
+    def extendMarkdownBlocks(self, md, blocks):
+        """Extend Markdown blocks."""
+
+        blocks.register(HTML, self.getConfigs())
+
+
+def makeExtension(*args, **kwargs):
+    """Return extension."""
+
+    return HTMLExtension(*args, **kwargs)
diff --git a/pymdownx/blocks/tab.py b/pymdownx/blocks/tab.py
index 4e5057703..16a190e7e 100644
--- a/pymdownx/blocks/tab.py
+++ b/pymdownx/blocks/tab.py
@@ -3,6 +3,7 @@
 from markdown.extensions import toc
 from markdown.treeprocessors import Treeprocessor
 from .block import Block, type_boolean
+from ..blocks import BlocksExtension
 
 
 class TabbedTreeprocessor(Treeprocessor):
@@ -241,3 +242,32 @@ def on_create(self, parent):
         tab_group.attrib['data-tabs'] = '%d:%d' % (tab_set, tab_count)
 
         return tab_group
+
+
+class TabExtension(BlocksExtension):
+    """Admonition Blocks Extension."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize."""
+
+        self.config = {
+            'alternate_style': [False, "Use alternate style - Default: False"],
+            'slugify': [0, "Slugify function used to create tab specific IDs - Default: None"],
+            'separator': ['-', "Slug separator - Default: '-'"]
+        }
+
+        super().__init__(*args, **kwargs)
+
+    def extendMarkdownBlocks(self, md, blocks):
+        """Extend Markdown blocks."""
+
+        blocks.register(Tab, self.getConfigs())
+        if callable(self.getConfig('slugify')):
+            slugs = TabbedTreeprocessor(md, self.getConfigs())
+            md.treeprocessors.register(slugs, 'tab_slugs', 4)
+
+
+def makeExtension(*args, **kwargs):
+    """Return extension."""
+
+    return TabExtension(*args, **kwargs)
diff --git a/tests/test_extensions/test_blocks/test_admonitions.py b/tests/test_extensions/test_blocks/test_admonitions.py
index 6033868be..f4a74b719 100644
--- a/tests/test_extensions/test_blocks/test_admonitions.py
+++ b/tests/test_extensions/test_blocks/test_admonitions.py
@@ -5,11 +5,9 @@
 class TestBlocksAdmonitions(util.MdCase):
     """Test Blocks admonitions cases."""
 
-    extension = ['pymdownx.blocks']
+    extension = ['pymdownx.blocks.admonition']
     extension_configs = {
-        'pymdownx.blocks': {
-            'blocks': {'pymdownx.blocks.admonition:Admonition': {'types': ['note', 'custom']}}
-        }
+        'pymdownx.blocks.admonition': {'types': ['note', 'custom']}
     }
 
     def test_optional_title(self):
diff --git a/tests/test_extensions/test_blocks/test_definition.py b/tests/test_extensions/test_blocks/test_definition.py
index a867a967e..a8c297416 100644
--- a/tests/test_extensions/test_blocks/test_definition.py
+++ b/tests/test_extensions/test_blocks/test_definition.py
@@ -5,12 +5,7 @@
 class TestBlocksDefinition(util.MdCase):
     """Test Blocks admonitions cases."""
 
-    extension = ['pymdownx.blocks']
-    extension_configs = {
-        'pymdownx.blocks': {
-            'blocks': {'pymdownx.blocks.definition:Definition': None, 'pymdownx.blocks.html:HTML': None}
-        }
-    }
+    extension = ['pymdownx.blocks.definition', 'pymdownx.blocks.html']
 
     def test_def(self):
         """Test definition."""
diff --git a/tests/test_extensions/test_blocks/test_details.py b/tests/test_extensions/test_blocks/test_details.py
index b97b45e71..504fde863 100644
--- a/tests/test_extensions/test_blocks/test_details.py
+++ b/tests/test_extensions/test_blocks/test_details.py
@@ -5,11 +5,9 @@
 class TestBlocksDetails(util.MdCase):
     """Test Blocks details cases."""
 
-    extension = ['pymdownx.blocks']
+    extension = ['pymdownx.blocks.details']
     extension_configs = {
-        'pymdownx.blocks': {
-            'blocks': {'pymdownx.blocks.details:Details': {'types': ['custom']}}
-        }
+        'pymdownx.blocks.details': {'types': ['custom']}
     }
 
     def test_optional_title(self):
diff --git a/tests/test_extensions/test_blocks/test_general_blocks.py b/tests/test_extensions/test_blocks/test_general_blocks.py
index 0ae3a2d07..adf053506 100644
--- a/tests/test_extensions/test_blocks/test_general_blocks.py
+++ b/tests/test_extensions/test_blocks/test_general_blocks.py
@@ -111,473 +111,468 @@ def test_type_html_classes(self):
         self.assertEqual(['this', 'that'], block.type_html_classes('this that'))
 
 
-class TestGeneral(unittest.TestCase):
-    """Test general cases."""
+# class TestGeneral(unittest.TestCase):
+#     """Test general cases."""
 
-    def test_attribute_override(self):
-        """Test that attributes cannot be overridden."""
+#     def test_attribute_override(self):
+#         """Test that attributes cannot be overridden."""
 
-        class AttrOverride(block.Block):
-            NAME = 'override'
+#         class AttrOverride(block.Block):
+#             NAME = 'override'
 
-            OPTIONS = {
-                'attrs': [False, block.type_boolean],
-            }
+#             OPTIONS = {
+#                 'attrs': [False, block.type_boolean],
+#             }
 
-            def on_create(self, parent):
-                """Create."""
+#             def on_create(self, parent):
+#                 """Create."""
 
-                return etree.SubElement(parent, 'div')
+#                 return etree.SubElement(parent, 'div')
 
-        with self.assertRaises(ValueError):
-            markdown.markdown(
-                '/// override\n///',
-                extensions=['pymdownx.blocks'],
-                extension_configs={'pymdownx.blocks': {'blocks': {AttrOverride: None}}}
-            )
-
-    def test_duplicate_blocks(self):
-        """Test duplicate blocks."""
-
-        with self.assertRaises(ValueError):
-            markdown.markdown(
-                '/// override\n///',
-                extensions=['pymdownx.blocks'],
-                extension_configs={
-                    'pymdownx.blocks': {
-                        'blocks': {'pymdownx.blocks.admonition:Admonition': {'types': ['danger', 'danger']}}
-                    }
-                }
-            )
-
-
-class TestBlockUndefinedOption(util.MdCase):
-    """Test Blocks with undefined options."""
-
-    class UndefinedBlock(block.Block):
-        """Undefined option block."""
-
-        NAME = 'undefined'
-
-        def on_create(self, parent):
-            """Create."""
-
-            return etree.SubElement(parent, 'div')
-
-    extension = ['pymdownx.blocks']
-    extension_configs = {'pymdownx.blocks': {'blocks': {UndefinedBlock: None}}}
-
-    def test_undefined_option(self):
-        """An undefined option will cause the block parsing to fail."""
-
-        self.check_markdown(
-            R'''
-            /// undefined
-                option: whatever
-
-            content
-            ///
-            ''',
-            '''
-            <p>/// undefined
-                option: whatever</p>
-            <p>content
-            ///</p>
-            ''',
-            True
-        )
-
-
-class TestMiscCases(util.MdCase):
-    """Test some miscellaneous cases."""
-
-    class MiscBlock(block.Block):
-        """A miscellaneous block."""
-
-        NAME = 'misc'
-        OPTIONS = {'test': ['whatever', block.type_string]}
-
-        def on_create(self, parent):
-            """Create."""
-
-            return etree.SubElement(parent, 'div', {'test': self.options['test']})
-
-    class MiscInline(block.Block):
-        """A miscellaneous block."""
-
-        NAME = 'miscinline'
+#         with self.assertRaises(ValueError):
+#             markdown.markdown(
+#                 '/// override\n///',
+#                 extensions=['pymdownx.blocks'],
+#                 extension_configs={'pymdownx.blocks': {'blocks': {AttrOverride: None}}}
+#             )
 
-        def on_create(self, parent):
-            """Create."""
+#     def test_duplicate_blocks(self):
+#         """Test duplicate blocks."""
 
-            return etree.SubElement(parent, 'span')
+#         with self.assertRaises(ValueError):
+#             markdown.markdown(
+#                 '/// override\n///',
+#                 extensions=['pymdownx.blocks'],
+#                 extension_configs={
+#                     'pymdownx.blocks': {
+#                         'blocks': {'pymdownx.blocks.admonition:Admonition': {'types': ['danger', 'danger']}}
+#                     }
+#                 }
+#             )
 
-    extension = ['pymdownx.blocks', 'pymdownx.superfences']
-    extension_configs = {'pymdownx.blocks': {'blocks': {MiscBlock: None, MiscInline: None}}}
 
-    def test_general_config(self):
-        """Test that content block should have a blank line between config."""
+# class TestBlockUndefinedOption(util.MdCase):
+#     """Test Blocks with undefined options."""
 
-        self.check_markdown(
-            R'''
-            /// misc
-                test: misc
-            content
-            ///
-            ''',
-            '''
-            <div test="misc">
-            <p>content</p>
-            </div>
-            ''',
-            True
-        )
-
-    def test_no_content(self):
-        """Test config and no content."""
-
-        self.check_markdown(
-            R'''
-            /// misc
-                test: misc
-            ///
-            ''',
-            '''
-            <div test="misc"></div>
-            ''',
-            True
-        )
-
-    def test_unfenced_config_and_no_content(self):
-        """Test no fenced config and no content."""
-
-        self.check_markdown(
-            R'''
-            /// misc
-                test: misc
-            ///
-            ''',
-            '''
-            <div test="misc"></div>
-            ''',
-            True
-        )
-
-    def test_content_after_only_config_block(self):
-        """Test content after only config block."""
-
-        self.check_markdown(
-            R'''
-            /// misc
-                test: misc
-            ///
-            more
-            ''',
-            '''
-            <div test="misc"></div>
-            <p>more</p>
-            ''',
-            True
-        )
-
-    def test_superfence_block(self):
-        """Test blocks with fenced code content."""
-
-        self.check_markdown(
-            R'''
-            /// misc
-            ```python
-            import foo
-            ```
-            ///
-            ''',
-            '''
-            <div test="whatever">
-            <div class="highlight"><pre><span></span><code><span class="kn">import</span> <span class="nn">foo</span>
-            </code></pre></div>
-            </div>
-            ''',
-            True
-        )
-
-    def test_superfence_inline(self):
-        """Test blocks with fenced code content."""
-
-        self.check_markdown(
-            R'''
-            /// miscinline
-            ```python
-            import foo
-            ```
-
-            Other content
-            ///
-            ''',
-            '''
-            <span><code>python
-            import foo</code>
-
-            Other content</span>
-            ''',
-            True
-        )
-
-
-class TestMiscYAMLFenceCases(util.MdCase):
-    """Test some miscellaneous cases."""
-
-    class MiscBlock(block.Block):
-        """A miscellaneous block."""
-
-        NAME = 'misc'
-        OPTIONS = {'test': ['whatever', block.type_string]}
-
-        def on_create(self, parent):
-            """Create."""
-
-            return etree.SubElement(parent, 'div', {'test': self.options['test']})
-
-    extension = ['pymdownx.blocks', 'pymdownx.superfences']
-    extension_configs = {'pymdownx.blocks': {'blocks': {MiscBlock: None}}}
-
-    def test_no_config(self):
-        """Test no YAML config and no new line."""
-
-        self.check_markdown(
-            R'''
-            /// misc
-            content
-            ///
-            ''',
-            '''
-            <div test="whatever">
-            <p>content</p>
-            </div>
-            ''',
-            True
-        )
-
-    def test_config_no_new_line(self):
-        """Test YAML config and no new line."""
-
-        self.check_markdown(
-            R'''
-            /// misc
-                test: tag
-            content
-            ///
-            ''',
-            '''
-            <div test="tag">
-            <p>content</p>
-            </div>
-            ''',
-            True
-        )
-
-    def test_config_no_fence(self):
-        """Test YAML config and no fence."""
-
-        self.check_markdown(
-            R'''
-            /// misc
-            test: tag
-
-            content
-            ///
-            ''',
-            '''
-            <div test="whatever">
-            <p>test: tag</p>
-            <p>content</p>
-            </div>
-            ''',
-            True
-        )
-
-    def test_config_with_new_line_before(self):
-        """Test YAML config and with new line before it."""
-
-        self.check_markdown(
-            R'''
-            /// misc
-
-                test: tag
-
-            content
-            ///
-            ''',
-            '''
-            <div test="whatever">
-            <pre><code>test: tag
-            </code></pre>
-            <p>content</p>
-            </div>
-            ''',
-            True
-        )
-
-
-class TestBadArgOptionParsers(util.MdCase):
-    """Test when a block's options do not fulfill the parser's expectations."""
-
-    class FailBlock(block.Block):
-        """Test failure to satisfy parser."""
-
-        NAME = 'fail'
-        ARGUMENTS = {'required': 1, 'parsers': [block.type_html_identifier]}
-        OPTIONS = {'test': ['tag', block.type_html_identifier]}
-
-        def on_create(self, parent):
-            """Create."""
-
-            return etree.SubElement(parent, 'div')
-
-    extension = ['pymdownx.blocks']
-    extension_configs = {'pymdownx.blocks': {'blocks': {FailBlock: None}}}
-
-    def test_fail_args(self):
-        """Test failure of arguments."""
-
-        self.check_markdown(
-            R'''
-            /// fail | 3tag
-            ///
-            ''',
-            '''
-            <p>/// fail | 3tag
-            ///</p>
-            ''',
-            True
-        )
-
-    def test_fail_opts(self):
-        """Test failure of options."""
-
-        self.check_markdown(
-            R'''
-            /// fail | tag
-                test: 3tag
-
-            content
-            ///
-            ''',
-            '''
-            <p>/// fail | tag
-                test: 3tag</p>
-            <p>content
-            ///</p>
-            ''',
-            True
-        )
-
-    def test_bad_config(self):
-        """Test when content is used in place of config."""
-
-        self.check_markdown(
-            R'''
-            /// fail | tag
-                content
-            ///
-            ''',
-            '''
-            <p>/// fail | tag
-                content
-            ///</p>
-            ''',
-            True
-        )
-
-    def test_bad_yaml(self):
-        """Test config is bad YAML."""
-
-        self.check_markdown(
-            R'''
-            /// fail | tag
-                :
-            ///
-            ''',
-            '''
-            <p>/// fail | tag
-                :
-            ///</p>
-            ''',
-            True
-        )
-
-
-class TestBlockSplit(util.MdCase):
-    """Test Blocks that split arguments."""
-
-    class SplitBlock(block.Block):
-        """Split block."""
-
-        NAME = 'split'
-
-        ARGUMENTS = {'required': 2}
-
-        def on_create(self, parent):
-            """Create."""
-
-            return etree.SubElement(parent, 'div', {self.args[0]: '0', self.args[1]: '1'})
-
-    extension = ['pymdownx.blocks']
-    extension_configs = {'pymdownx.blocks': {'blocks': {SplitBlock: None}}}
-
-    def test_split(self):
-        """Test that attributes cannot be overridden."""
-
-        self.check_markdown(
-            R'''
-            /// split | this that
-            ///
-            ''',
-            '''
-            <div that="1" this="0"></div>
-            ''',
-            True
-        )
-
-    def test_split_less(self):
-        """Test failure when arguments are too few."""
-
-        self.check_markdown(
-            R'''
-            /// split | this
-            ///
-            ''',
-            '''
-            <p>/// split | this
-            ///</p>
-            ''',
-            True
-        )
-
-    def test_split_greater(self):
-        """Test failure when arguments are too many."""
-
-        self.check_markdown(
-            R'''
-            /// split | this that another
-            ///
-            ''',
-            '''
-            <p>/// split | this that another
-            ///</p>
-            ''',
-            True
-        )
+#     class UndefinedBlock(block.Block):
+#         """Undefined option block."""
+
+#         NAME = 'undefined'
+
+#         def on_create(self, parent):
+#             """Create."""
+
+#             return etree.SubElement(parent, 'div')
+
+#     extension = ['pymdownx.blocks']
+#     extension_configs = {'pymdownx.blocks': {'blocks': {UndefinedBlock: None}}}
+
+#     def test_undefined_option(self):
+#         """An undefined option will cause the block parsing to fail."""
+
+#         self.check_markdown(
+#             R'''
+#             /// undefined
+#                 option: whatever
+
+#             content
+#             ///
+#             ''',
+#             '''
+#             <p>/// undefined
+#                 option: whatever</p>
+#             <p>content
+#             ///</p>
+#             ''',
+#             True
+#         )
+
+
+# class TestMiscCases(util.MdCase):
+#     """Test some miscellaneous cases."""
+
+#     class MiscBlock(block.Block):
+#         """A miscellaneous block."""
+
+#         NAME = 'misc'
+#         OPTIONS = {'test': ['whatever', block.type_string]}
+
+#         def on_create(self, parent):
+#             """Create."""
+
+#             return etree.SubElement(parent, 'div', {'test': self.options['test']})
+
+#     class MiscInline(block.Block):
+#         """A miscellaneous block."""
+
+#         NAME = 'miscinline'
+
+#         def on_create(self, parent):
+#             """Create."""
+
+#             return etree.SubElement(parent, 'span')
+
+#     extension = ['pymdownx.blocks', 'pymdownx.superfences']
+#     extension_configs = {'pymdownx.blocks': {'blocks': {MiscBlock: None, MiscInline: None}}}
+
+#     def test_general_config(self):
+#         """Test that content block should have a blank line between config."""
+
+#         self.check_markdown(
+#             R'''
+#             /// misc
+#                 test: misc
+#             content
+#             ///
+#             ''',
+#             '''
+#             <div test="misc">
+#             <p>content</p>
+#             </div>
+#             ''',
+#             True
+#         )
+
+#     def test_no_content(self):
+#         """Test config and no content."""
+
+#         self.check_markdown(
+#             R'''
+#             /// misc
+#                 test: misc
+#             ///
+#             ''',
+#             '''
+#             <div test="misc"></div>
+#             ''',
+#             True
+#         )
+
+#     def test_unfenced_config_and_no_content(self):
+#         """Test no fenced config and no content."""
+
+#         self.check_markdown(
+#             R'''
+#             /// misc
+#                 test: misc
+#             ///
+#             ''',
+#             '''
+#             <div test="misc"></div>
+#             ''',
+#             True
+#         )
+
+#     def test_content_after_only_config_block(self):
+#         """Test content after only config block."""
+
+#         self.check_markdown(
+#             R'''
+#             /// misc
+#                 test: misc
+#             ///
+#             more
+#             ''',
+#             '''
+#             <div test="misc"></div>
+#             <p>more</p>
+#             ''',
+#             True
+#         )
+
+#     def test_superfence_block(self):
+#         """Test blocks with fenced code content."""
+
+#         self.check_markdown(
+#             R'''
+#             /// misc
+#             ```python
+#             import foo
+#             ```
+#             ///
+#             ''',
+#             '''
+#             <div test="whatever">
+#             <div class="highlight"><pre><span></span><code><span class="kn">import</span> <span class="nn">foo</span>
+#             </code></pre></div>
+#             </div>
+#             ''',
+#             True
+#         )
+
+#     def test_superfence_inline(self):
+#         """Test blocks with fenced code content."""
+
+#         self.check_markdown(
+#             R'''
+#             /// miscinline
+#             ```python
+#             import foo
+#             ```
+
+#             Other content
+#             ///
+#             ''',
+#             '''
+#             <span><code>python
+#             import foo</code>
+
+#             Other content</span>
+#             ''',
+#             True
+#         )
+
+
+# class TestMiscYAMLFenceCases(util.MdCase):
+#     """Test some miscellaneous cases."""
+
+#     class MiscBlock(block.Block):
+#         """A miscellaneous block."""
+
+#         NAME = 'misc'
+#         OPTIONS = {'test': ['whatever', block.type_string]}
+
+#         def on_create(self, parent):
+#             """Create."""
+
+#             return etree.SubElement(parent, 'div', {'test': self.options['test']})
+
+#     extension = ['pymdownx.blocks', 'pymdownx.superfences']
+#     extension_configs = {'pymdownx.blocks': {'blocks': {MiscBlock: None}}}
+
+#     def test_no_config(self):
+#         """Test no YAML config and no new line."""
+
+#         self.check_markdown(
+#             R'''
+#             /// misc
+#             content
+#             ///
+#             ''',
+#             '''
+#             <div test="whatever">
+#             <p>content</p>
+#             </div>
+#             ''',
+#             True
+#         )
+
+#     def test_config_no_new_line(self):
+#         """Test YAML config and no new line."""
+
+#         self.check_markdown(
+#             R'''
+#             /// misc
+#                 test: tag
+#             content
+#             ///
+#             ''',
+#             '''
+#             <div test="tag">
+#             <p>content</p>
+#             </div>
+#             ''',
+#             True
+#         )
+
+#     def test_config_no_fence(self):
+#         """Test YAML config and no fence."""
+
+#         self.check_markdown(
+#             R'''
+#             /// misc
+#             test: tag
+
+#             content
+#             ///
+#             ''',
+#             '''
+#             <div test="whatever">
+#             <p>test: tag</p>
+#             <p>content</p>
+#             </div>
+#             ''',
+#             True
+#         )
+
+#     def test_config_with_new_line_before(self):
+#         """Test YAML config and with new line before it."""
+
+#         self.check_markdown(
+#             R'''
+#             /// misc
+
+#                 test: tag
+
+#             content
+#             ///
+#             ''',
+#             '''
+#             <div test="whatever">
+#             <pre><code>test: tag
+#             </code></pre>
+#             <p>content</p>
+#             </div>
+#             ''',
+#             True
+#         )
+
+
+# class TestBadArgOptionParsers(util.MdCase):
+#     """Test when a block's options do not fulfill the parser's expectations."""
+
+#     class FailBlock(block.Block):
+#         """Test failure to satisfy parser."""
+
+#         NAME = 'fail'
+#         ARGUMENTS = {'required': 1, 'parsers': [block.type_html_identifier]}
+#         OPTIONS = {'test': ['tag', block.type_html_identifier]}
+
+#         def on_create(self, parent):
+#             """Create."""
+
+#             return etree.SubElement(parent, 'div')
+
+#     extension = ['pymdownx.blocks']
+#     extension_configs = {'pymdownx.blocks': {'blocks': {FailBlock: None}}}
+
+#     def test_fail_args(self):
+#         """Test failure of arguments."""
+
+#         self.check_markdown(
+#             R'''
+#             /// fail | 3tag
+#             ///
+#             ''',
+#             '''
+#             <p>/// fail | 3tag
+#             ///</p>
+#             ''',
+#             True
+#         )
+
+#     def test_fail_opts(self):
+#         """Test failure of options."""
+
+#         self.check_markdown(
+#             R'''
+#             /// fail | tag
+#                 test: 3tag
+
+#             content
+#             ///
+#             ''',
+#             '''
+#             <p>/// fail | tag
+#                 test: 3tag</p>
+#             <p>content
+#             ///</p>
+#             ''',
+#             True
+#         )
+
+#     def test_bad_config(self):
+#         """Test when content is used in place of config."""
+
+#         self.check_markdown(
+#             R'''
+#             /// fail | tag
+#                 content
+#             ///
+#             ''',
+#             '''
+#             <p>/// fail | tag
+#                 content
+#             ///</p>
+#             ''',
+#             True
+#         )
+
+#     def test_bad_yaml(self):
+#         """Test config is bad YAML."""
+
+#         self.check_markdown(
+#             R'''
+#             /// fail | tag
+#                 :
+#             ///
+#             ''',
+#             '''
+#             <p>/// fail | tag
+#                 :
+#             ///</p>
+#             ''',
+#             True
+#         )
+
+
+# class TestBlockSplit(util.MdCase):
+#     """Test Blocks that split arguments."""
+
+#     class SplitBlock(block.Block):
+#         """Split block."""
+
+#         NAME = 'split'
+
+#         ARGUMENTS = {'required': 2}
+
+#         def on_create(self, parent):
+#             """Create."""
+
+#             return etree.SubElement(parent, 'div', {self.args[0]: '0', self.args[1]: '1'})
+
+#     extension = ['pymdownx.blocks']
+#     extension_configs = {'pymdownx.blocks': {'blocks': {SplitBlock: None}}}
+
+#     def test_split(self):
+#         """Test that attributes cannot be overridden."""
+
+#         self.check_markdown(
+#             R'''
+#             /// split | this that
+#             ///
+#             ''',
+#             '''
+#             <div that="1" this="0"></div>
+#             ''',
+#             True
+#         )
+
+#     def test_split_less(self):
+#         """Test failure when arguments are too few."""
+
+#         self.check_markdown(
+#             R'''
+#             /// split | this
+#             ///
+#             ''',
+#             '''
+#             <p>/// split | this
+#             ///</p>
+#             ''',
+#             True
+#         )
+
+#     def test_split_greater(self):
+#         """Test failure when arguments are too many."""
+
+#         self.check_markdown(
+#             R'''
+#             /// split | this that another
+#             ///
+#             ''',
+#             '''
+#             <p>/// split | this that another
+#             ///</p>
+#             ''',
+#             True
+#         )
 
 
 class TestAttributes(util.MdCase):
     """Test Blocks tab cases."""
 
-    extension = ['pymdownx.blocks']
-    extension_configs = {
-        'pymdownx.blocks': {
-            'blocks': {'pymdownx.blocks.admonition:Admonition': None}
-        }
-    }
+    extension = ['pymdownx.blocks.admonition']
 
     def test_attributes(self):
         """Test attributes."""
@@ -622,11 +617,9 @@ def test_bad_attributes(self):
 class TestBlocksTab(util.MdCase):
     """Test Blocks tab cases."""
 
-    extension = ['pymdownx.blocks', 'pymdownx.superfences', 'markdown.extensions.def_list', 'pymdownx.details']
+    extension = ['pymdownx.blocks.tab', 'pymdownx.superfences', 'markdown.extensions.def_list', 'pymdownx.details']
     extension_configs = {
-        'pymdownx.blocks': {
-            'blocks': {'pymdownx.blocks.tab:Tab': {'alternate_style': True}}
-        }
+        'pymdownx.blocks.tab': {'alternate_style': True}
     }
 
     def test_with_preceding_text(self):
diff --git a/tests/test_extensions/test_blocks/test_html.py b/tests/test_extensions/test_blocks/test_html.py
index 4d48028c6..fba2c2613 100644
--- a/tests/test_extensions/test_blocks/test_html.py
+++ b/tests/test_extensions/test_blocks/test_html.py
@@ -5,12 +5,7 @@
 class TestBlocksHTML(util.MdCase):
     """Test Blocks HTML cases."""
 
-    extension = ['pymdownx.blocks']
-    extension_configs = {
-        'pymdownx.blocks': {
-            'blocks': {'pymdownx.blocks.html:HTML': None}
-        }
-    }
+    extension = ['pymdownx.blocks.html']
 
     def test_bad_tag(self):
         """Test bad HTML tag."""
diff --git a/tests/test_extensions/test_blocks/test_legacy_tab.py b/tests/test_extensions/test_blocks/test_legacy_tab.py
index c32f51bd2..c8e742dbf 100644
--- a/tests/test_extensions/test_blocks/test_legacy_tab.py
+++ b/tests/test_extensions/test_blocks/test_legacy_tab.py
@@ -6,11 +6,9 @@
 class TestLegacyTabSlugs(util.MdCase):
     """Test legacy tab slug cases."""
 
-    extension = ['pymdownx.blocks', 'toc']
+    extension = ['pymdownx.blocks.tab', 'toc']
     extension_configs = {
-        'pymdownx.blocks': {
-            'blocks': {'pymdownx.blocks.tab:Tab': {'slugify': slugify(case='lower')}},
-        }
+        'pymdownx.blocks.tab': {'slugify': slugify(case='lower')}
     }
 
     MD = r"""
@@ -47,11 +45,9 @@ def test_tab_slugs(self):
 class TestLegacyTabSlugsSep(util.MdCase):
     """Test legacy tab slug separator cases."""
 
-    extension = ['pymdownx.blocks', 'toc']
+    extension = ['pymdownx.blocks.tab', 'toc']
     extension_configs = {
-        'pymdownx.blocks': {
-            'blocks': {'pymdownx.blocks.tab:Tab': {'slugify': slugify(case='lower'), 'separator': '_'}}
-        }
+        'pymdownx.blocks.tab': {'slugify': slugify(case='lower'), 'separator': '_'}
     }
 
     MD = r"""
@@ -88,12 +84,7 @@ def test_slug_with_separator(self):
 class TestBlocksLegacyTab(util.MdCase):
     """Test Blocks legacy tab cases."""
 
-    extension = ['pymdownx.blocks', 'pymdownx.superfences', 'markdown.extensions.def_list', 'pymdownx.details']
-    extension_configs = {
-        'pymdownx.blocks': {
-            'blocks': {'pymdownx.blocks.tab:Tab': None}
-        }
-    }
+    extension = ['pymdownx.blocks.tab', 'pymdownx.superfences', 'markdown.extensions.def_list', 'pymdownx.details']
 
     def test_tabbed_select(self):
         """Test selecting a tab."""
diff --git a/tests/test_extensions/test_blocks/test_tab.py b/tests/test_extensions/test_blocks/test_tab.py
index 64f3ec6eb..f9b1e6ee3 100644
--- a/tests/test_extensions/test_blocks/test_tab.py
+++ b/tests/test_extensions/test_blocks/test_tab.py
@@ -6,11 +6,9 @@
 class TestTabSlugs(util.MdCase):
     """Test tab slug cases."""
 
-    extension = ['pymdownx.blocks', 'toc']
+    extension = ['pymdownx.blocks.tab', 'toc']
     extension_configs = {
-        'pymdownx.blocks': {
-            'blocks': {'pymdownx.blocks.tab:Tab': {'slugify': slugify(case='lower'), 'alternate_style': True}}
-        }
+        'pymdownx.blocks.tab': {'slugify': slugify(case='lower'), 'alternate_style': True}
     }
 
     MD = r"""
@@ -50,16 +48,12 @@ def test_tab_slugs(self):
 class TestTabSlugsSep(util.MdCase):
     """Test tab slug separator cases."""
 
-    extension = ['pymdownx.blocks', 'toc']
+    extension = ['pymdownx.blocks.tab', 'toc']
     extension_configs = {
-        'pymdownx.blocks': {
-            'blocks': {
-                'pymdownx.blocks.tab:Tab': {
-                    'slugify': slugify(case='lower'),
-                    'separator': '_',
-                    'alternate_style': True
-                }
-            }
+        'pymdownx.blocks.tab': {
+            'slugify': slugify(case='lower'),
+            'separator': '_',
+            'alternate_style': True
         }
     }
 
@@ -100,11 +94,9 @@ def test_slug_with_separator(self):
 class TestBlocksTab(util.MdCase):
     """Test Blocks tab cases."""
 
-    extension = ['pymdownx.blocks', 'pymdownx.superfences', 'markdown.extensions.def_list', 'pymdownx.details']
+    extension = ['pymdownx.blocks.tab', 'pymdownx.superfences', 'markdown.extensions.def_list', 'pymdownx.details']
     extension_configs = {
-        'pymdownx.blocks': {
-            'blocks': {'pymdownx.blocks.tab:Tab': {'alternate_style': True}}
-        }
+        'pymdownx.blocks.tab': {'alternate_style': True}
     }
 
     def test_tabbed_select(self):
diff --git a/tools/collapse_code.py b/tools/collapse_code.py
index afb96aa27..aaaac100f 100644
--- a/tools/collapse_code.py
+++ b/tools/collapse_code.py
@@ -2,7 +2,8 @@
 import xml.etree.ElementTree as etree
 from markdown import util as mutil
 import re
-from pymdownx.blocks.block import Block  # noqa: E402
+from pymdownx.blocks.block import Block
+from pymdownx.blocks import BlocksExtension
 
 # Fenced block placeholder for SuperFences
 FENCED_BLOCK_RE = re.compile(
@@ -18,12 +19,6 @@ class CollapseCode(Block):
     """Collapse code."""
 
     NAME = 'collapse-code'
-    CONFIG = {
-        'expand_text': 'Expand',
-        'collapse_text': 'Collapse',
-        'expand_title': 'expand',
-        'collapse_title': 'collapse'
-    }
 
     def on_init(self):
         """Handle initialization."""
@@ -89,3 +84,30 @@ def on_end(self, block):
             {'for': '__collapse{}'.format(self.count), 'class': 'collapse', 'title': self.collapse_title}
         )
         collapse.text = self.collapse
+
+
+class CollapseCodeExtension(BlocksExtension):
+    """Admonition Blocks Extension."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize."""
+
+        self.config = {
+            'expand_text': ['Expand', "Set the text for the expand button."],
+            'collapse_text': ['Collapse', "Set the text for the collapse button."],
+            'expand_title': ['expand', "Set the text for the expand title."],
+            'collapse_title': ['collapse', "Set the text for the collapse title."]
+        }
+
+        super().__init__(*args, **kwargs)
+
+    def extendMarkdownBlocks(self, md, blocks):
+        """Extend Markdown blocks."""
+
+        blocks.register(CollapseCode, self.getConfigs())
+
+
+def makeExtension(*args, **kwargs):
+    """Return extension."""
+
+    return CollapseCodeExtension(*args, **kwargs)