From a78dcf3e9e37faf693ef4bdbddc393e246999b0d Mon Sep 17 00:00:00 2001
From: facelessuser <faceless.shop@gmail.com>
Date: Wed, 22 Sep 2021 19:45:37 -0600
Subject: [PATCH 1/6] Experimental: Recognize audio/video links in img syntax

---
 pymdownx/magiclink.py | 131 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 131 insertions(+)

diff --git a/pymdownx/magiclink.py b/pymdownx/magiclink.py
index 61978b53b..135f24c36 100644
--- a/pymdownx/magiclink.py
+++ b/pymdownx/magiclink.py
@@ -30,6 +30,7 @@
 from . import util
 import re
 from markdown.inlinepatterns import LinkInlineProcessor, InlineProcessor
+import copy
 
 MAGIC_LINK = 1
 MAGIC_AUTO_LINK = 2
@@ -217,6 +218,128 @@
 }
 
 
+class MagiclinkMediaTreeprocessor(Treeprocessor):
+    """
+    Find video links and parse them up.
+
+    We'll use the image link syntax to identify our links of interest.
+    """
+
+    # Current recognized file extensions
+    MIMES = re.compile(r'(?i).*?\.(mp3|ogg|wav|flac|mp4|webm)$')
+
+    # Default MIME types, but can be overridden
+    MIMEMAP = {
+        'mp4': 'video/mp4',
+        'webm': 'video/webm',
+        'mp3': 'audio/mpeg',
+        'ogg': 'audio/ogg',
+        'wav': 'audio/wav',
+        'flac': 'audio/flac'
+    }
+
+    def __init__(self, md, in_img, in_anchor):
+        """Initialize."""
+
+        self.in_img = in_img
+        self.in_anchor = in_anchor
+
+        super().__init__(md)
+
+    def run(self, root):
+        """Shorten popular git repository links."""
+
+        # Grab the elements of interest and form a parent mapping
+        links = [e for e in root.iter() if e.tag.lower() in ('img',)]
+        parent_map = {c: p for p in root.iter() for c in p}
+
+        # Evaluate links
+        for link in reversed(links):
+
+            # Save the attributes as we will reuse them
+            attrib = copy.copy(link.attrib)
+
+            # See if source matches the audio or video mime type
+            src = attrib.get('src', '')
+            m = self.MIMES.match(src)
+            if m is None:
+                continue
+
+            # Use whatever audio/video type specified or construct our own
+            # Reject any other types
+            mime = m.group(1).lower()
+
+            # We don't know what case the attributes are in
+            # so take care to find them. Sort out source attributes
+            # and audio/video attributes.
+            stop = False
+            src_attrib = {'src': src}
+            del attrib['src']
+            for k in list(attrib.keys()):
+                key = k.lower()
+
+                if key == 'type':
+                    v = attrib[k]
+                    t = v.lower().split('/')[0]
+                    if t in ('audio', 'video'):
+                        src_attrib[key] = v
+                        del attrib[k]
+                    else:
+                        stop = True
+                        break
+
+                elif key in ('srcset', 'sizes', 'media'):
+                    src_attrib[key] = attrib[k]
+                    del attrib[key]
+
+            # We must have found an incompatible type
+            if stop:
+                break
+
+            # No type found, set it from our mapping
+            if 'type' not in src_attrib:
+                src_attrib['type'] = self.MIMEMAP[mime]
+
+            # Setup media controls
+            attrib['controls'] = ''
+
+            # Build the source element and apply the right type
+            source = etree.Element('source', src_attrib)
+
+            # Find the parent and check if the next sibling is already a media group
+            # that we can attach to. If so, the current link will become the primary
+            # source, and the existing will become the fallback.
+            parent = parent_map[link]
+            one_more = False
+            sibling = None
+            index = -1
+            mtype = src_attrib['type'][:5].lower()
+            for i, c in enumerate(parent, 0):
+                if one_more:
+                    # If there is another sibling, see if it is already a video container
+                    if c.tag.lower() == mtype:
+                        sibling = c
+                    break
+                if c is link:
+                    # Found where we live, now let's find our sibling
+                    index = i
+                    one_more = True
+
+            # Attach the media source as the primary source, or construct a new group.
+            if sibling is not None:
+                sibling.insert(0, source)
+                sibling.attrib = attrib
+            else:
+                media = etree.Element(mtype, attrib)
+                media.append(source)
+                parent.insert(index, media)
+
+            # Remove the old link
+            parent.remove(link)
+
+        return root
+
+
 class _MagiclinkShorthandPattern(InlineProcessor):
     """Base shorthand link class."""
 
@@ -992,6 +1115,12 @@ def setup_shortener(self, md, base_url, base_user_url, config, repo_shortner, so
         shortener.config = config
         md.treeprocessors.register(shortener, "magic-repo-shortener", 9.9)
 
+    def setup_media(self, md, in_img, in_anchor):
+        """Setup media transformations."""
+
+        media = MagiclinkMediaTreeprocessor(md, in_img, in_anchor)
+        md.treeprocessors.register(media, 'magic-video', 7.9)
+
     def get_base_urls(self, config):
         """Get base URLs."""
 
@@ -1053,6 +1182,8 @@ def extendMarkdown(self, md):
             base_url, base_user_url = self.get_base_urls(config)
             self.setup_shortener(md, base_url, base_user_url, config, self.repo_shortner, self.social_shortener)
 
+        self.setup_media(md, True, True)
+
 
 def makeExtension(*args, **kwargs):
     """Return extension."""

From e8b360c176262edec116cf783a4ee8b043f2064d Mon Sep 17 00:00:00 2001
From: facelessuser <faceless.shop@gmail.com>
Date: Wed, 22 Sep 2021 21:12:45 -0600
Subject: [PATCH 2/6] Provide a message and download as absolute last fallback

Use alt as a description in the message
Also, use sibling videos/audio if fallback is defined
---
 pymdownx/magiclink.py | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/pymdownx/magiclink.py b/pymdownx/magiclink.py
index 135f24c36..7023df620 100644
--- a/pymdownx/magiclink.py
+++ b/pymdownx/magiclink.py
@@ -238,6 +238,10 @@ class MagiclinkMediaTreeprocessor(Treeprocessor):
         'flac': 'audio/flac'
     }
 
+    MEDIA_FAIL = "Sorry, your browser doesn't support embedded videos."
+    MEDIA_DOWNLOAD = "Try downloading a copy of the video."
+    MEDIA_DESCRIPTION = "Description: {}"
+
     def __init__(self, md, in_img, in_anchor):
         """Initialize."""
 
@@ -275,10 +279,14 @@ def run(self, root):
             stop = False
             src_attrib = {'src': src}
             del attrib['src']
+            alt = ''
             for k in list(attrib.keys()):
                 key = k.lower()
 
-                if key == 'type':
+                if key == 'alt':
+                    alt = attrib[k]
+                    del attrib[k]
+                elif key == 'type':
                     v = attrib[k]
                     t = v.lower().split('/')[0]
                     if t in ('audio', 'video'):
@@ -317,7 +325,7 @@ def run(self, root):
             for i, c in enumerate(parent, 0):
                 if one_more:
                     # If there is another sibling, see if it is already a video container
-                    if c.tag.lower() == mtype:
+                    if c.tag.lower() == mtype and 'fallback' in c.attrib:
                         sibling = c
                     break
                 if c is link:
@@ -329,9 +337,17 @@ def run(self, root):
             if sibling is not None:
                 sibling.insert(0, source)
                 sibling.attrib = attrib
+                last = list(sibling)[-1]
+                last.attrib['href'] = src
+                last.tail = md_util.AtomicString(self.MEDIA_DESCRIPTION.format(alt) if alt else '')
             else:
                 media = etree.Element(mtype, attrib)
                 media.append(source)
+                source.tail = md_util.AtomicString(self.MEDIA_FAIL)
+                download = etree.SubElement(media, 'a', {"href": src, "download": ""})
+                download.text = md_util.AtomicString(self.MEDIA_DOWNLOAD)
+                if alt:
+                    download.tail = md_util.AtomicString(self.MEDIA_DESCRIPTION.format(alt))
                 parent.insert(index, media)
 
             # Remove the old link

From 431924098cead2856c5fb14a5cf4fee62c08dbdd Mon Sep 17 00:00:00 2001
From: facelessuser <faceless.shop@gmail.com>
Date: Thu, 23 Sep 2021 06:31:38 -0600
Subject: [PATCH 3/6] Allow global default attributes which can be overridden,
 also cleanup

---
 pymdownx/magiclink.py | 82 +++++++++++++++++++++++++------------------
 1 file changed, 47 insertions(+), 35 deletions(-)

diff --git a/pymdownx/magiclink.py b/pymdownx/magiclink.py
index 7023df620..8d9eda4e7 100644
--- a/pymdownx/magiclink.py
+++ b/pymdownx/magiclink.py
@@ -242,11 +242,11 @@ class MagiclinkMediaTreeprocessor(Treeprocessor):
     MEDIA_DOWNLOAD = "Try downloading a copy of the video."
     MEDIA_DESCRIPTION = "Description: {}"
 
-    def __init__(self, md, in_img, in_anchor):
+    def __init__(self, md, video_defaults, audio_defaults):
         """Initialize."""
 
-        self.in_img = in_img
-        self.in_anchor = in_anchor
+        self.video_defaults = video_defaults
+        self.audio_defaults = audio_defaults
 
         super().__init__(md)
 
@@ -273,44 +273,43 @@ def run(self, root):
             # Reject any other types
             mime = m.group(1).lower()
 
-            # We don't know what case the attributes are in
-            # so take care to find them. Sort out source attributes
-            # and audio/video attributes.
-            stop = False
-            src_attrib = {'src': src}
+            # We don't know what case the attributes are in, so normalize them.
+            keys = set([k.lower() for k in attrib.keys()])
+
+            # Identify whether we are working with audio or video and save MIME type
+            mtype = ''
+            if 'type' in keys:
+                v = attrib['type']
+                t = v.lower().split('/')[0]
+                if t in ('audio', 'video'):
+                    mtype = v
+                    keys.remove('type')
+            else:
+                mtype = self.MIMEMAP.get(mime, '')
+                attrib['type'] = mtype
+
+            # Doesn't look like audio/video
+            if not mtype:
+                continue
+
+            # Setup attributess for `<source>` element
+            vtype = mtype[:5].lower()
+            attrib = {**copy.deepcopy(self.video_defaults if vtype == 'video' else self.audio_defaults), **attrib}
+            src_attrib = {'src': src, 'type': mtype}
             del attrib['src']
+            del attrib['type']
+
+            # Find any other `<source>` specific attributes and check if there is an `alt`
             alt = ''
-            for k in list(attrib.keys()):
+            for k in keys:
                 key = k.lower()
-
                 if key == 'alt':
                     alt = attrib[k]
                     del attrib[k]
-                elif key == 'type':
-                    v = attrib[k]
-                    t = v.lower().split('/')[0]
-                    if t in ('audio', 'video'):
-                        src_attrib[key] = v
-                        del attrib[k]
-                    else:
-                        stop = True
-                        break
-
                 elif key in ('srcset', 'sizes', 'media'):
                     src_attrib[key] = attrib[k]
                     del attrib[key]
 
-            # We must have found an incompatible type
-            if stop:
-                break
-
-            # No type found, set it from our mapping
-            if 'type' not in src_attrib:
-                src_attrib['type'] = self.MIMEMAP[mime]
-
-            # Setup media controls
-            attrib['controls'] = ''
-
             # Build the source element and apply the right type
             source = etree.Element('source', src_attrib)
 
@@ -336,7 +335,8 @@ def run(self, root):
             # Attach the media source as the primary source, or construct a new group.
             if sibling is not None:
                 sibling.insert(0, source)
-                sibling.attrib = attrib
+                sibling.attrib.clear()
+                sibling.attrib.update(attrib)
                 last = list(sibling)[-1]
                 last.attrib['href'] = src
                 last.tail = md_util.AtomicString(self.MEDIA_DESCRIPTION.format(alt) if alt else '')
@@ -1054,6 +1054,14 @@ def __init__(self, *args, **kwargs):
             'repo': [
                 '',
                 'The base repo to use - Default: ""'
+            ],
+            "video_defaults": [
+                {'controls': '', 'preload': 'metadata'},
+                "Video default attributes - Default: {}"
+            ],
+            "audio_defaults": [
+                {'controls': '', 'preload': 'metadata'},
+                "Video default attributes - Default: {}"
             ]
         }
         super(MagiclinkExtension, self).__init__(*args, **kwargs)
@@ -1131,10 +1139,10 @@ def setup_shortener(self, md, base_url, base_user_url, config, repo_shortner, so
         shortener.config = config
         md.treeprocessors.register(shortener, "magic-repo-shortener", 9.9)
 
-    def setup_media(self, md, in_img, in_anchor):
+    def setup_media(self, md, video_defaults, audio_defaults):
         """Setup media transformations."""
 
-        media = MagiclinkMediaTreeprocessor(md, in_img, in_anchor)
+        media = MagiclinkMediaTreeprocessor(md, video_defaults, audio_defaults)
         md.treeprocessors.register(media, 'magic-video', 7.9)
 
     def get_base_urls(self, config):
@@ -1198,7 +1206,11 @@ def extendMarkdown(self, md):
             base_url, base_user_url = self.get_base_urls(config)
             self.setup_shortener(md, base_url, base_user_url, config, self.repo_shortner, self.social_shortener)
 
-        self.setup_media(md, True, True)
+        self.setup_media(
+            md,
+            config['video_defaults'],
+            config['audio_defaults']
+        )
 
 
 def makeExtension(*args, **kwargs):

From 4bda1cf04f81033f76cbb670101d3de60702daf7 Mon Sep 17 00:00:00 2001
From: facelessuser <faceless.shop@gmail.com>
Date: Thu, 23 Sep 2021 13:00:54 -0600
Subject: [PATCH 4/6] Move media embedding to a new Embed extension

- Allow any extension as long as a MIME type of audio/video is provided
- Remove fallback message. Only show a download link with alt text if
  provided an if not, the link will show the URL.
---
 docs/src/mkdocs.yml   |   1 +
 mkdocs.yml            |   1 +
 pymdownx/embed.py     | 186 ++++++++++++++++++++++++++++++++++++++++++
 pymdownx/magiclink.py | 159 ------------------------------------
 4 files changed, 188 insertions(+), 159 deletions(-)
 create mode 100644 pymdownx/embed.py

diff --git a/docs/src/mkdocs.yml b/docs/src/mkdocs.yml
index 2b33bfd8f..4473f7fb2 100644
--- a/docs/src/mkdocs.yml
+++ b/docs/src/mkdocs.yml
@@ -153,6 +153,7 @@ markdown_extensions:
   - pymdownx.tabbed:
       alternate_style: true
   - pymdownx.saneheaders:
+  - pymdownx.embed:
 
 extra:
   social:
diff --git a/mkdocs.yml b/mkdocs.yml
index 6b53a810c..9948d3183 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -153,6 +153,7 @@ markdown_extensions:
   - pymdownx.tabbed:
       alternate_style: true
   - pymdownx.saneheaders:
+  - pymdownx.embed:
 
 extra:
   social:
diff --git a/pymdownx/embed.py b/pymdownx/embed.py
new file mode 100644
index 000000000..ca3f82310
--- /dev/null
+++ b/pymdownx/embed.py
@@ -0,0 +1,186 @@
+"""Library for embedding media and such."""
+from markdown import Extension
+from markdown.treeprocessors import Treeprocessor
+from markdown import util as md_util
+import xml.etree.ElementTree as etree
+import re
+import copy
+
+
+class EmbedMediaTreeprocessor(Treeprocessor):
+    """
+    Find video links and parse them up.
+
+    We'll use the image link syntax to identify our links of interest.
+    """
+
+    # Current recognized file extensions
+    MIMES = re.compile(r'(?i).*?\.([a-z0-9]+)$')
+
+    # Default MIME types, but can be overridden
+    # These are just MIME types we know, but some can be
+    # audio or video, and we cannot predict without a type
+    # in those cases. So any of these can be overridden if
+    # a type is provided, but if none is provided, we take
+    # our best guess.
+    MIMEMAP = {
+        'mp4': 'video/mp4',
+        'webm': 'video/webm',
+        'mp3': 'audio/mpeg',
+        'ogg': 'audio/ogg',
+        'wav': 'audio/wav',
+        'flac': 'audio/flac'
+    }
+
+    def __init__(self, md, video_defaults, audio_defaults):
+        """Initialize."""
+
+        self.video_defaults = video_defaults
+        self.audio_defaults = audio_defaults
+
+        super().__init__(md)
+
+    def run(self, root):
+        """Shorten popular git repository links."""
+
+        # Grab the elements of interest and form a parent mapping
+        links = [e for e in root.iter() if e.tag.lower() in ('img',)]
+        parent_map = {c: p for p in root.iter() for c in p}
+
+        # Evaluate links
+        for link in reversed(links):
+
+            # Save the attributes as we will reuse them
+            attrib = copy.copy(link.attrib)
+
+            # See if source matches the audio or video mime type
+            src = attrib.get('src', '')
+            m = self.MIMES.match(src)
+            if m is None:
+                continue
+
+            # Use whatever audio/video type specified or construct our own
+            # Reject any other types
+            mime = m.group(1).lower()
+
+            # We don't know what case the attributes are in, so normalize them.
+            keys = set([k.lower() for k in attrib.keys()])
+
+            # Identify whether we are working with audio or video and save MIME type
+            mtype = ''
+            if 'type' in keys:
+                v = attrib['type']
+                t = v.lower().split('/')[0]
+                if t in ('audio', 'video'):
+                    mtype = v
+                    keys.remove('type')
+            else:
+                mtype = self.MIMEMAP.get(mime, '')
+                attrib['type'] = mtype
+
+            # Doesn't look like audio/video
+            if not mtype:
+                continue
+
+            # Setup attributess for `<source>` element
+            vtype = mtype[:5].lower()
+            attrib = {**copy.deepcopy(self.video_defaults if vtype == 'video' else self.audio_defaults), **attrib}
+            src_attrib = {'src': src, 'type': mtype}
+            del attrib['src']
+            del attrib['type']
+
+            # Find any other `<source>` specific attributes and check if there is an `alt`
+            alt = ''
+            for k in keys:
+                key = k.lower()
+                if key == 'alt':
+                    alt = attrib[k]
+                    del attrib[k]
+                elif key in ('srcset', 'sizes', 'media'):
+                    src_attrib[key] = attrib[k]
+                    del attrib[key]
+
+            # Build the source element and apply the right type
+            source = etree.Element('source', src_attrib)
+
+            # Find the parent and check if the next sibling is already a media group
+            # that we can attach to. If so, the current link will become the primary
+            # source, and the existing will become the fallback.
+            parent = parent_map[link]
+            one_more = False
+            sibling = None
+            index = -1
+            mtype = src_attrib['type'][:5].lower()
+            for i, c in enumerate(parent, 0):
+                if one_more:
+                    # If there is another sibling, see if it is already a video container
+                    if c.tag.lower() == mtype and 'fallback' in c.attrib:
+                        sibling = c
+                    break
+                if c is link:
+                    # Found where we live, now let's find our sibling
+                    index = i
+                    one_more = True
+
+            # Attach the media source as the primary source, or construct a new group.
+            if sibling is not None:
+                # Insert the source at the top
+                sibling.insert(0, source)
+                # Update container's attributes
+                sibling.attrib.clear()
+                sibling.attrib.update(attrib)
+                # Update fallback link
+                last = list(sibling)[-1]
+                last.attrib['href'] = src
+                last.text = md_util.AtomicString(alt if alt else src)
+            else:
+                # Create media container and insert source
+                media = etree.Element(mtype, attrib)
+                media.append(source)
+                # Just in case the browser doesn't support `<video>` or `<audio>`
+                download = etree.SubElement(media, 'a', {"href": src, "download": ""})
+                download.text = md_util.AtomicString(alt if alt else src)
+                # Insert media where the old link was
+                parent.insert(index, media)
+
+            # Remove the old link
+            parent.remove(link)
+
+        return root
+
+
+class EmbedExtension(Extension):
+    """Add auto link and link transformation extensions to Markdown class."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize."""
+
+        self.config = {
+            "video_defaults": [
+                {'controls': '', 'preload': 'metadata'},
+                "Video default attributes - Default: {}"
+            ],
+            "audio_defaults": [
+                {'controls': '', 'preload': 'metadata'},
+                "Video default attributes - Default: {}"
+            ]
+        }
+        super().__init__(*args, **kwargs)
+
+    def extendMarkdown(self, md):
+        """Add support for turning html links and emails to link tags."""
+
+        config = self.getConfigs()
+
+        media = EmbedMediaTreeprocessor(
+            md,
+            config['video_defaults'],
+            config['audio_defaults']
+        )
+        md.treeprocessors.register(media, 'embed', 7.9)
+
+
+def makeExtension(*args, **kwargs):
+    """Return extension."""
+
+    return EmbedExtension(*args, **kwargs)
diff --git a/pymdownx/magiclink.py b/pymdownx/magiclink.py
index 8d9eda4e7..61978b53b 100644
--- a/pymdownx/magiclink.py
+++ b/pymdownx/magiclink.py
@@ -30,7 +30,6 @@
 from . import util
 import re
 from markdown.inlinepatterns import LinkInlineProcessor, InlineProcessor
-import copy
 
 MAGIC_LINK = 1
 MAGIC_AUTO_LINK = 2
@@ -218,144 +217,6 @@
 }
 
 
-class MagiclinkMediaTreeprocessor(Treeprocessor):
-    """
-    Find video links and parse them up.
-
-    We'll use the image link syntax to identify our links of interest.
-    """
-
-    # Current recognized file extensions
-    MIMES = re.compile(r'(?i).*?\.(mp3|ogg|wav|flac|mp4|webm)$')
-
-    # Default MIME types, but can be overridden
-    MIMEMAP = {
-        'mp4': 'video/mp4',
-        'webm': 'video/webm',
-        'mp3': 'audio/mpeg',
-        'ogg': 'audio/ogg',
-        'wav': 'audio/wav',
-        'flac': 'audio/flac'
-    }
-
-    MEDIA_FAIL = "Sorry, your browser doesn't support embedded videos."
-    MEDIA_DOWNLOAD = "Try downloading a copy of the video."
-    MEDIA_DESCRIPTION = "Description: {}"
-
-    def __init__(self, md, video_defaults, audio_defaults):
-        """Initialize."""
-
-        self.video_defaults = video_defaults
-        self.audio_defaults = audio_defaults
-
-        super().__init__(md)
-
-    def run(self, root):
-        """Shorten popular git repository links."""
-
-        # Grab the elements of interest and form a parent mapping
-        links = [e for e in root.iter() if e.tag.lower() in ('img',)]
-        parent_map = {c: p for p in root.iter() for c in p}
-
-        # Evaluate links
-        for link in reversed(links):
-
-            # Save the attributes as we will reuse them
-            attrib = copy.copy(link.attrib)
-
-            # See if source matches the audio or video mime type
-            src = attrib.get('src', '')
-            m = self.MIMES.match(src)
-            if m is None:
-                continue
-
-            # Use whatever audio/video type specified or construct our own
-            # Reject any other types
-            mime = m.group(1).lower()
-
-            # We don't know what case the attributes are in, so normalize them.
-            keys = set([k.lower() for k in attrib.keys()])
-
-            # Identify whether we are working with audio or video and save MIME type
-            mtype = ''
-            if 'type' in keys:
-                v = attrib['type']
-                t = v.lower().split('/')[0]
-                if t in ('audio', 'video'):
-                    mtype = v
-                    keys.remove('type')
-            else:
-                mtype = self.MIMEMAP.get(mime, '')
-                attrib['type'] = mtype
-
-            # Doesn't look like audio/video
-            if not mtype:
-                continue
-
-            # Setup attributess for `<source>` element
-            vtype = mtype[:5].lower()
-            attrib = {**copy.deepcopy(self.video_defaults if vtype == 'video' else self.audio_defaults), **attrib}
-            src_attrib = {'src': src, 'type': mtype}
-            del attrib['src']
-            del attrib['type']
-
-            # Find any other `<source>` specific attributes and check if there is an `alt`
-            alt = ''
-            for k in keys:
-                key = k.lower()
-                if key == 'alt':
-                    alt = attrib[k]
-                    del attrib[k]
-                elif key in ('srcset', 'sizes', 'media'):
-                    src_attrib[key] = attrib[k]
-                    del attrib[key]
-
-            # Build the source element and apply the right type
-            source = etree.Element('source', src_attrib)
-
-            # Find the parent and check if the next sibling is already a media group
-            # that we can attach to. If so, the current link will become the primary
-            # source, and the existing will become the fallback.
-            parent = parent_map[link]
-            one_more = False
-            sibling = None
-            index = -1
-            mtype = src_attrib['type'][:5].lower()
-            for i, c in enumerate(parent, 0):
-                if one_more:
-                    # If there is another sibling, see if it is already a video container
-                    if c.tag.lower() == mtype and 'fallback' in c.attrib:
-                        sibling = c
-                    break
-                if c is link:
-                    # Found where we live, now let's find our sibling
-                    index = i
-                    one_more = True
-
-            # Attach the media source as the primary source, or construct a new group.
-            if sibling is not None:
-                sibling.insert(0, source)
-                sibling.attrib.clear()
-                sibling.attrib.update(attrib)
-                last = list(sibling)[-1]
-                last.attrib['href'] = src
-                last.tail = md_util.AtomicString(self.MEDIA_DESCRIPTION.format(alt) if alt else '')
-            else:
-                media = etree.Element(mtype, attrib)
-                media.append(source)
-                source.tail = md_util.AtomicString(self.MEDIA_FAIL)
-                download = etree.SubElement(media, 'a', {"href": src, "download": ""})
-                download.text = md_util.AtomicString(self.MEDIA_DOWNLOAD)
-                if alt:
-                    download.tail = md_util.AtomicString(self.MEDIA_DESCRIPTION.format(alt))
-                parent.insert(index, media)
-
-            # Remove the old link
-            parent.remove(link)
-
-        return root
-
-
 class _MagiclinkShorthandPattern(InlineProcessor):
     """Base shorthand link class."""
 
@@ -1054,14 +915,6 @@ def __init__(self, *args, **kwargs):
             'repo': [
                 '',
                 'The base repo to use - Default: ""'
-            ],
-            "video_defaults": [
-                {'controls': '', 'preload': 'metadata'},
-                "Video default attributes - Default: {}"
-            ],
-            "audio_defaults": [
-                {'controls': '', 'preload': 'metadata'},
-                "Video default attributes - Default: {}"
             ]
         }
         super(MagiclinkExtension, self).__init__(*args, **kwargs)
@@ -1139,12 +992,6 @@ def setup_shortener(self, md, base_url, base_user_url, config, repo_shortner, so
         shortener.config = config
         md.treeprocessors.register(shortener, "magic-repo-shortener", 9.9)
 
-    def setup_media(self, md, video_defaults, audio_defaults):
-        """Setup media transformations."""
-
-        media = MagiclinkMediaTreeprocessor(md, video_defaults, audio_defaults)
-        md.treeprocessors.register(media, 'magic-video', 7.9)
-
     def get_base_urls(self, config):
         """Get base URLs."""
 
@@ -1206,12 +1053,6 @@ def extendMarkdown(self, md):
             base_url, base_user_url = self.get_base_urls(config)
             self.setup_shortener(md, base_url, base_user_url, config, self.repo_shortner, self.social_shortener)
 
-        self.setup_media(
-            md,
-            config['video_defaults'],
-            config['audio_defaults']
-        )
-
 
 def makeExtension(*args, **kwargs):
     """Return extension."""

From e33d122e141b8baabbfdf79d055aed18979dd250 Mon Sep 17 00:00:00 2001
From: facelessuser <faceless.shop@gmail.com>
Date: Thu, 23 Sep 2021 19:09:33 -0600
Subject: [PATCH 5/6] Add support for media services like YouTube, etc.

---
 pymdownx/embed.py | 129 ++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 120 insertions(+), 9 deletions(-)

diff --git a/pymdownx/embed.py b/pymdownx/embed.py
index ca3f82310..21ace5af4 100644
--- a/pymdownx/embed.py
+++ b/pymdownx/embed.py
@@ -7,6 +7,77 @@
 import copy
 
 
+RE_YOUTUBE = re.compile(
+    r"""(?ix)^
+    (?:https://(?:www\.)?youtube\.com/embed/|https://youtu\.be/|https://www.youtube.com/watch?v=)
+    (?P<id>[a-z0-9-]+)(?P<extra>[?&].*)?$
+    """
+)
+
+RE_DAILYMOTION = re.compile(
+    r"""(?ix)^
+    (?:https://(?:www\.)?dailymotion\.com/(?:embed/)?video/)
+    (?P<id>[a-z0-9]+)(?P<extra>[?&].*)?$
+    """
+)
+
+RE_VIMEO = re.compile(
+    r"""(?ix)^
+    (?:https://(?:www\.)?vimeo\.com/|https://player\.vimeo\.com/video/)
+    (?P<id>[0-9]+)(?P<extra>[?&].*)?$
+    """
+)
+
+
+def youtube(url):
+    """Match YouTube source and return a suitable URL."""
+
+    src = None
+    m = RE_YOUTUBE.match(url)
+    if m:
+        key = m.group('id')
+        src = 'https://www.youtube.com/embed/{}'.format(key)
+    return src
+
+
+def dailymotion(url):
+    """Match Dailymotion source and return a suitable URL."""
+
+    src = None
+    m = RE_DAILYMOTION.match(url)
+    if m:
+        key = m.group('id')
+        src = 'https://www.dailymotion.com/embed/video/{}'.format(key)
+    return src
+
+
+def vimeo(url):
+    """Match Vimeo source and return a suitable URL."""
+
+    src = None
+    m = RE_VIMEO.match(url)
+    if m:
+        key = m.group('id')
+        src = 'https://player.vimeo.com/video/{}'.format(key)
+    return src
+
+
+SERVICES = {
+    "youtube": {
+        "handler": youtube,
+        "defaults": {"allowfullscreen": '', "frameborder": '0'}
+    },
+    "dailymotion": {
+        "handler": dailymotion,
+        "defaults": {"allowfullscreen": '', "frameborder": '0'}
+    },
+    "vimeo": {
+        "handler": vimeo,
+        "defaults": {"allowfullscreen": '', "frameborder": '0'}
+    }
+}
+
+
 class EmbedMediaTreeprocessor(Treeprocessor):
     """
     Find video links and parse them up.
@@ -32,20 +103,22 @@ class EmbedMediaTreeprocessor(Treeprocessor):
         'flac': 'audio/flac'
     }
 
-    def __init__(self, md, video_defaults, audio_defaults):
+    def __init__(self, md, video_defaults, audio_defaults, services):
         """Initialize."""
 
+        self.services = copy.deepcopy(SERVICES)
+        for k, v in services.items():
+            if k not in self.services:
+                self.services[k] = copy.deepcopy(v)
+            else:
+                self.services[k] = {**self.services[k], **copy.deepcopy(v)}
         self.video_defaults = video_defaults
         self.audio_defaults = audio_defaults
 
         super().__init__(md)
 
-    def run(self, root):
-        """Shorten popular git repository links."""
-
-        # Grab the elements of interest and form a parent mapping
-        links = [e for e in root.iter() if e.tag.lower() in ('img',)]
-        parent_map = {c: p for p in root.iter() for c in p}
+    def process_embedded_media(self, links, parent_map):
+        """Process embedded video and audio files."""
 
         # Evaluate links
         for link in reversed(links):
@@ -146,6 +219,42 @@ def run(self, root):
             # Remove the old link
             parent.remove(link)
 
+    def process_embedded_media_service(self, links, parent_map):
+        """Process links to embedded media services like YouTube, etc."""
+
+        for link in reversed(links):
+            for service in self.services.values():
+                src = service['handler'](link.attrib.get('href', ''))
+                if src:
+                    orig = copy.copy(link.attrib)
+                    orig['src'] = src
+                    del orig['href']
+                    attrib = {**copy.copy(service['defaults']), **orig}
+                    el = etree.Element('iframe', attrib)
+                    parent = parent_map[link]
+                    for index, c in enumerate(list(parent), 0):
+                        if c is el:
+                            break
+                    parent.insert(index, el)
+                    parent.remove(link)
+
+    def run(self, root):
+        """Shorten popular git repository links."""
+
+        # Grab the elements of interest and form a parent mapping
+        images = []
+        anchors = []
+        parent_map = {c: p for p in root.iter() for c in p}
+        for e in root.iter():
+            tag = e.tag.lower()
+            if tag == 'img':
+                images.append(e)
+            elif tag == 'a':
+                anchors.append(e)
+
+        self.process_embedded_media(images, parent_map)
+        self.process_embedded_media_service(anchors, parent_map)
+
         return root
 
 
@@ -163,7 +272,8 @@ def __init__(self, *args, **kwargs):
             "audio_defaults": [
                 {'controls': '', 'preload': 'metadata'},
                 "Video default attributes - Default: {}"
-            ]
+            ],
+            "services": [{}, "Additional services and service overrides."]
         }
         super().__init__(*args, **kwargs)
 
@@ -175,7 +285,8 @@ def extendMarkdown(self, md):
         media = EmbedMediaTreeprocessor(
             md,
             config['video_defaults'],
-            config['audio_defaults']
+            config['audio_defaults'],
+            config['services']
         )
         md.treeprocessors.register(media, 'embed', 7.9)
 

From 5e8dc6c719d2c76bac001816d96d48cbe89a99d6 Mon Sep 17 00:00:00 2001
From: facelessuser <faceless.shop@gmail.com>
Date: Fri, 24 Sep 2021 09:55:29 -0600
Subject: [PATCH 6/6] Make vtt subtitles work and alter syntax of vid services
 to use `![]()`

---
 docs/src/dictionary/en-custom.txt |   3 +
 pymdownx/embed.py                 | 282 ++++++++++++++++++------------
 pymdownx/magiclink.py             |   3 +
 3 files changed, 181 insertions(+), 107 deletions(-)

diff --git a/docs/src/dictionary/en-custom.txt b/docs/src/dictionary/en-custom.txt
index 596eb749c..d18fbb115 100644
--- a/docs/src/dictionary/en-custom.txt
+++ b/docs/src/dictionary/en-custom.txt
@@ -20,6 +20,7 @@ CommonMark
 CriticMarkup
 Ctrl
 DOM
+Dailymotion
 Dicts
 Donath
 ElementTree
@@ -110,6 +111,7 @@ UTF
 Uml
 Unescape
 Validators
+Vimeo
 Virtualenv
 Waylan
 YAML
@@ -142,6 +144,7 @@ emojione
 escaper
 eslint
 facelessuser
+fallbacks
 formatter
 formatter's
 formatters
diff --git a/pymdownx/embed.py b/pymdownx/embed.py
index 21ace5af4..90e85b7c0 100644
--- a/pymdownx/embed.py
+++ b/pymdownx/embed.py
@@ -28,6 +28,9 @@
     """
 )
 
+SOURCE_ATTR = ('srcset', 'sizes', 'media')
+TRACK_ATTR = ('default', 'kind', 'label', 'srclang')
+
 
 def youtube(url):
     """Match YouTube source and return a suitable URL."""
@@ -65,15 +68,27 @@ def vimeo(url):
 SERVICES = {
     "youtube": {
         "handler": youtube,
-        "defaults": {"allowfullscreen": '', "frameborder": '0'}
+        "defaults": {
+            "allowfullscreen": '',
+            "frameborder": '0',
+            "title": "YouTube video player"
+        }
     },
     "dailymotion": {
         "handler": dailymotion,
-        "defaults": {"allowfullscreen": '', "frameborder": '0'}
+        "defaults": {
+            "allowfullscreen": '',
+            "frameborder": '0',
+            "title": "Dailymotion video player"
+        }
     },
     "vimeo": {
         "handler": vimeo,
-        "defaults": {"allowfullscreen": '', "frameborder": '0'}
+        "defaults": {
+            "allowfullscreen": '',
+            "frameborder": '0',
+            "title": "Vimeo video player"
+        }
     }
 }
 
@@ -117,30 +132,45 @@ def __init__(self, md, video_defaults, audio_defaults, services):
 
         super().__init__(md)
 
-    def process_embedded_media(self, links, parent_map):
-        """Process embedded video and audio files."""
+    def convert_to_anchor(self, link, parent_map):
+        """Convert to a normal link."""
 
-        # Evaluate links
-        for link in reversed(links):
+        parent = parent_map[link]
+        el = None
+        index = -1
+        for index, c in enumerate(list(parent), 0):
+            if c is link:
+                src = link.attrib['src']
+                el = etree.Element('a', {'href': src, 'download': ''})
+                el.text = md_util.AtomicString(src)
+                break
 
-            # Save the attributes as we will reuse them
-            attrib = copy.copy(link.attrib)
+        parent.insert(index, el)
+        parent.remove(link)
 
-            # See if source matches the audio or video mime type
-            src = attrib.get('src', '')
-            m = self.MIMES.match(src)
-            if m is None:
-                continue
+    def process_embedded_media(self, link, parent_map):
+        """Process embedded video and audio files."""
 
-            # Use whatever audio/video type specified or construct our own
-            # Reject any other types
-            mime = m.group(1).lower()
+        # Save the attributes as we will reuse them
+        attrib = copy.copy(link.attrib)
 
-            # We don't know what case the attributes are in, so normalize them.
-            keys = set([k.lower() for k in attrib.keys()])
+        # See if source matches the audio or video mime type
+        src = attrib.get('src', '')
+        m = self.MIMES.match(src)
+        if m is None:
+            return
 
-            # Identify whether we are working with audio or video and save MIME type
-            mtype = ''
+        # Use whatever audio/video type specified or construct our own
+        # Reject any other types
+        mime = m.group(1).lower()
+        is_vtt = mime == 'vtt'
+
+        # We don't know what case the attributes are in, so normalize them.
+        keys = set([k.lower() for k in attrib.keys()])
+
+        # Identify whether we are working with audio or video and save MIME type
+        mtype = ''
+        if not is_vtt:
             if 'type' in keys:
                 v = attrib['type']
                 t = v.lower().split('/')[0]
@@ -153,107 +183,145 @@ def process_embedded_media(self, links, parent_map):
 
             # Doesn't look like audio/video
             if not mtype:
-                continue
+                return
 
-            # Setup attributess for `<source>` element
+            # Setup attributes for `<source>` element
             vtype = mtype[:5].lower()
             attrib = {**copy.deepcopy(self.video_defaults if vtype == 'video' else self.audio_defaults), **attrib}
             src_attrib = {'src': src, 'type': mtype}
             del attrib['src']
             del attrib['type']
+        else:
+            # We need `<track>` elements to be fallbacks.
+            if 'fallback' not in keys:
+                self.convert_to_anchor(link, parent_map)
+                return
+            # Setup attributes for `<track>` element.
+            src_attrib = {'src': src}
+            del attrib['src']
 
-            # Find any other `<source>` specific attributes and check if there is an `alt`
-            alt = ''
-            for k in keys:
-                key = k.lower()
-                if key == 'alt':
-                    alt = attrib[k]
-                    del attrib[k]
-                elif key in ('srcset', 'sizes', 'media'):
-                    src_attrib[key] = attrib[k]
-                    del attrib[key]
-
-            # Build the source element and apply the right type
-            source = etree.Element('source', src_attrib)
-
-            # Find the parent and check if the next sibling is already a media group
-            # that we can attach to. If so, the current link will become the primary
-            # source, and the existing will become the fallback.
-            parent = parent_map[link]
-            one_more = False
-            sibling = None
-            index = -1
-            mtype = src_attrib['type'][:5].lower()
-            for i, c in enumerate(parent, 0):
-                if one_more:
-                    # If there is another sibling, see if it is already a video container
-                    if c.tag.lower() == mtype and 'fallback' in c.attrib:
-                        sibling = c
-                    break
-                if c is link:
-                    # Found where we live, now let's find our sibling
-                    index = i
-                    one_more = True
-
-            # Attach the media source as the primary source, or construct a new group.
-            if sibling is not None:
-                # Insert the source at the top
-                sibling.insert(0, source)
-                # Update container's attributes
-                sibling.attrib.clear()
-                sibling.attrib.update(attrib)
-                # Update fallback link
-                last = list(sibling)[-1]
-                last.attrib['href'] = src
-                last.text = md_util.AtomicString(alt if alt else src)
-            else:
-                # Create media container and insert source
-                media = etree.Element(mtype, attrib)
-                media.append(source)
-                # Just in case the browser doesn't support `<video>` or `<audio>`
-                download = etree.SubElement(media, 'a', {"href": src, "download": ""})
-                download.text = md_util.AtomicString(alt if alt else src)
-                # Insert media where the old link was
-                parent.insert(index, media)
-
-            # Remove the old link
-            parent.remove(link)
-
-    def process_embedded_media_service(self, links, parent_map):
+        # Find any other `<source>` specific attributes and check if there is an `alt`
+        # Also handle any for `<track>`.
+        alt = ''
+        title = ''
+        fallback = False
+        for k in keys:
+            key = k.lower()
+            if key == 'alt':
+                alt = attrib[k]
+                del attrib[k]
+            elif key == 'title':
+                title = attrib[k]
+            elif key == 'fallback':
+                fallback = True
+                del attrib[k]
+            elif not is_vtt and key in SOURCE_ATTR:
+                src_attrib[key] = attrib[k]
+                del attrib[k]
+            elif is_vtt and key in TRACK_ATTR:
+                src_attrib[key] = attrib[k]
+                del attrib[k]
+            elif key in SOURCE_ATTR or key in TRACK_ATTR:
+                del attrib[k]
+
+        # Use the title as `alt` if none was provided.
+        # As a last resort, we'll just use the `src` as the `alt`
+        if not alt:
+            alt = title
+        if not alt:
+            alt = src
+
+        # Find the parent and check if the next sibling is already a media group
+        # that we can attach to. If so, the current link will become the primary
+        # source, and the existing will become the fallback.
+        parent = parent_map[link]
+        index = -1
+        mtype = src_attrib['type'][:5].lower() if not is_vtt else 'track'
+        prev = None
+        for i, c in enumerate(parent, 0):
+            if c is link:
+                # Found where we live, now let's find our sibling
+                fallback = fallback and (prev and (mtype == prev.tag.lower() or mtype == 'track'))
+                index = len(list(prev)) - 1 if fallback else i
+                break
+            prev = c
+
+        # Track with no parent
+        if mtype == 'track' and not fallback:
+            self.convert_to_anchor(link, parent_map)
+            return
+
+        # Build the source element and apply the right type
+        source = etree.Element('source' if not is_vtt else 'track', src_attrib)
+
+        # Attach the media source as the primary source, or construct a new group.
+        if fallback:
+            # Insert the source at the top
+            prev.insert(index, source)
+        else:
+            # Create media container and insert source
+            media = etree.Element(mtype, attrib)
+            media.append(source)
+            # Just in case the browser doesn't support `<video>` or `<audio>`
+            download = etree.SubElement(media, 'a', {"href": src, "download": ""})
+            download.text = md_util.AtomicString(alt)
+            # Insert media where the old link was
+            parent.insert(index, media)
+
+        # Remove the old link
+        parent.remove(link)
+
+    def process_embedded_media_service(self, link, parent_map):
         """Process links to embedded media services like YouTube, etc."""
 
-        for link in reversed(links):
-            for service in self.services.values():
-                src = service['handler'](link.attrib.get('href', ''))
-                if src:
-                    orig = copy.copy(link.attrib)
-                    orig['src'] = src
-                    del orig['href']
-                    attrib = {**copy.copy(service['defaults']), **orig}
-                    el = etree.Element('iframe', attrib)
-                    parent = parent_map[link]
-                    for index, c in enumerate(list(parent), 0):
-                        if c is el:
-                            break
-                    parent.insert(index, el)
-                    parent.remove(link)
+        processed = False
+        for service in self.services.values():
+            src = service['handler'](link.attrib.get('src', ''))
+            if src:
+                orig = copy.copy(link.attrib)
+                orig['src'] = src
+
+                alt = ''
+                title = ''
+                # We don't know what case the attributes are in, so normalize them.
+                keys = set([k.lower() for k in orig.keys()])
+                for k in keys:
+                    key = k.lower()
+                    if key == 'alt':
+                        alt = orig[k]
+                        del orig[k]
+                    elif key == 'title':
+                        title = orig[k]
+                        del orig[k]
+
+                if not title:
+                    title = alt
+
+                if title:
+                    orig['title'] = title
+
+                attrib = {**copy.copy(service['defaults']), **orig}
+                el = etree.Element('iframe', attrib)
+                parent = parent_map[link]
+                for index, c in enumerate(list(parent), 0):
+                    if c is el:
+                        break
+                parent.insert(index, el)
+                parent.remove(link)
+                processed = True
+                break
+        return processed
 
     def run(self, root):
         """Shorten popular git repository links."""
 
         # Grab the elements of interest and form a parent mapping
-        images = []
-        anchors = []
         parent_map = {c: p for p in root.iter() for c in p}
-        for e in root.iter():
-            tag = e.tag.lower()
-            if tag == 'img':
-                images.append(e)
-            elif tag == 'a':
-                anchors.append(e)
-
-        self.process_embedded_media(images, parent_map)
-        self.process_embedded_media_service(anchors, parent_map)
+        links = [e for e in root.iter() if e.tag.lower() == 'img']
+
+        for link in links:
+            if not self.process_embedded_media_service(link, parent_map):
+                self.process_embedded_media(link, parent_map)
 
         return root
 
diff --git a/pymdownx/magiclink.py b/pymdownx/magiclink.py
index 61978b53b..bed3cced8 100644
--- a/pymdownx/magiclink.py
+++ b/pymdownx/magiclink.py
@@ -515,6 +515,7 @@ def get_provider(self, match):
         """Get the provider and hash size."""
 
         # Set provider specific variables
+        provider = ''
         if match.group('github'):
             provider = 'github'
         elif match.group('bitbucket'):
@@ -526,6 +527,7 @@ def get_provider(self, match):
     def get_social_provider(self, match):
         """Get social provider."""
 
+        provider = ''
         if match.group('twitter'):
             provider = 'twitter'
         return provider
@@ -533,6 +535,7 @@ def get_social_provider(self, match):
     def get_type(self, provider, match):
         """Get the link type."""
 
+        value = link_type = None
         try:
             # Gather info about link type
             if match.group(provider + '_diff1') is not None: