Merge d4664a53467eade879971de3950424299f68bd3a into 420d53387cff54ea1fccca061438d59bdb50a39c

[JSInterp] Improve tests
* from yt-dlp/yt-dlp#12313 * also fix d7c2708
2025-07-16 16:34:13 +09:00 · 2025-03-16 13:09:11 +00:00 · 2025-03-11 02:00:24 +00:00 · 2025-03-11 02:00:24 +00:00 · 2025-03-11 02:00:24 +00:00 · 2025-03-11 02:00:24 +00:00
11 changed files with 1284 additions and 66 deletions
--- a/3
+++ b/3
@ -246,4 +246,5 @@ Enes Solak
 Nathan Rossi
 Thomas van der Berg
 Luca Cherubin
-Adrian Heine
+Adrian Heine
+Henrik Heimbuerger
--- a/test/test_jsinterp.py
+++ b/test/test_jsinterp.py
@ -11,6 +11,7 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

 import math
 import re
+import time

 from youtube_dl.compat import compat_str as str
 from youtube_dl.jsinterp import JS_Undefined, JSInterpreter
@ -208,6 +209,34 @@ class TestJSInterpreter(unittest.TestCase):
        self._test(jsi, 86000, args=['12/31/1969 18:01:26 MDT'])
        # epoch 0
        self._test(jsi, 0, args=['1 January 1970 00:00:00 UTC'])
+        # undefined
+        self._test(jsi, NaN, args=[JS_Undefined])
+        # y,m,d, ... - may fail with older dates lacking DST data
+        jsi = JSInterpreter(
+            'function f() { return new Date(%s); }'
+            % ('2024, 5, 29, 2, 52, 12, 42',))
+        self._test(jsi, (
+            1719625932042                           # UK value
+            + (
+                + 3600                              # back to GMT
+                + (time.altzone if time.daylight    # host's DST
+                   else time.timezone)
+            ) * 1000))
+        # no arg
+        self.assertAlmostEqual(JSInterpreter(
+            'function f() { return new Date() - 0; }').call_function('f'),
+            time.time() * 1000, delta=100)
+        # Date.now()
+        self.assertAlmostEqual(JSInterpreter(
+            'function f() { return Date.now(); }').call_function('f'),
+            time.time() * 1000, delta=100)
+        # Date.parse()
+        jsi = JSInterpreter('function f(dt) { return Date.parse(dt); }')
+        self._test(jsi, 0, args=['1 January 1970 00:00:00 UTC'])
+        # Date.UTC()
+        jsi = JSInterpreter('function f() { return Date.UTC(%s); }'
+                            % ('1970, 0, 1, 0, 0, 0, 0',))
+        self._test(jsi, 0)

    def test_call(self):
        jsi = JSInterpreter('''
@ -463,6 +492,14 @@ class TestJSInterpreter(unittest.TestCase):
        self._test('function f(){return NaN << 42}', 0)
        self._test('function f(){return "21.9" << 1}', 42)
        self._test('function f(){return 21 << 4294967297}', 42)
+        self._test('function f(){return true << "5";}', 32)
+        self._test('function f(){return true << true;}', 2)
+        self._test('function f(){return "19" & "21.9";}', 17)
+        self._test('function f(){return "19" & false;}', 0)
+        self._test('function f(){return "11.0" >> "2.1";}', 2)
+        self._test('function f(){return 5 ^ 9;}', 12)
+        self._test('function f(){return 0.0 << NaN}', 0)
+        self._test('function f(){return null << undefined}', 0)

    def test_negative(self):
        self._test('function f(){return 2    *    -2.0    ;}', -4)
--- a/test/test_youtube_signature.py
+++ b/test/test_youtube_signature.py
@ -223,6 +223,18 @@ _NSIG_TESTS = [
        'https://www.youtube.com/s/player/9c6dfc4a/player_ias.vflset/en_US/base.js',
        'jbu7ylIosQHyJyJV', 'uwI0ESiynAmhNg',
    ),
+    (
+        'https://www.youtube.com/s/player/f6e09c70/player_ias.vflset/en_US/base.js',
+        'W9HJZKktxuYoDTqW', 'jHbbkcaxm54',
+    ),
+    (
+        'https://www.youtube.com/s/player/f6e09c70/player_ias_tce.vflset/en_US/base.js',
+        'W9HJZKktxuYoDTqW', 'jHbbkcaxm54',
+    ),
+    (
+        'https://www.youtube.com/s/player/91201489/player_ias_tce.vflset/en_US/base.js',
+        'W9HJZKktxuYoDTqW', 'U48vOZHaeYS6vO',
+    ),
 ]


@ -284,7 +296,7 @@ def t_factory(name, sig_func, url_pattern):


 def signature(jscode, sig_input):
-    func = YoutubeIE(FakeYDL())._parse_sig_js(jscode)
+    func = YoutubeIE(FakeYDL({'cachedir': False}))._parse_sig_js(jscode)
    src_sig = (
        compat_str(string.printable[:sig_input])
        if isinstance(sig_input, int) else sig_input)
@ -292,9 +304,10 @@ def signature(jscode, sig_input):


 def n_sig(jscode, sig_input):
-    funcname = YoutubeIE(FakeYDL())._extract_n_function_name(jscode)
-    return JSInterpreter(jscode).call_function(
-        funcname, sig_input, _ytdl_do_not_return=sig_input)
+    ie = YoutubeIE(FakeYDL({'cachedir': False}))
+    jsi = JSInterpreter(jscode)
+    jsi, _, func_code = ie._extract_n_function_code_jsi(sig_input, jsi)
+    return ie._extract_n_function_from_code(jsi, func_code)(sig_input)


 make_sig_test = t_factory(
--- a/youtube_dl/init.py
+++ b/youtube_dl/init.py
@ -18,7 +18,7 @@ from .compat import (
    compat_getpass,
    compat_register_utf8,
    compat_shlex_split,
-    workaround_optparse_bug9161,
+    _workaround_optparse_bug9161,
 )
 from .utils import (
    _UnsafeExtensionError,
@ -50,7 +50,7 @@ def _real_main(argv=None):
    # Compatibility fix for Windows
    compat_register_utf8()

-    workaround_optparse_bug9161()
+    _workaround_optparse_bug9161()

    setproctitle('youtube-dl')

--- a/youtube_dl/compat.py
+++ b/youtube_dl/compat.py
@ -16,7 +16,6 @@ import os
 import platform
 import re
 import shlex
-import shutil
 import socket
 import struct
 import subprocess
@ -24,11 +23,15 @@ import sys
 import types
 import xml.etree.ElementTree

+_IDENTITY = lambda x: x
+
 # naming convention
 # 'compat_' + Python3_name.replace('.', '_')
 # other aliases exist for convenience and/or legacy
+# wrap disposable test values in type() to reclaim storage

-# deal with critical unicode/str things first
+# deal with critical unicode/str things first:
+# compat_str, compat_basestring, compat_chr
 try:
    # Python 2
    compat_str, compat_basestring, compat_chr = (
@ -39,18 +42,23 @@ except NameError:
        str, (str, bytes), chr
    )

-# casefold
+
+# compat_casefold
 try:
    compat_str.casefold
    compat_casefold = lambda s: s.casefold()
 except AttributeError:
    from .casefold import _casefold as compat_casefold

+
+# compat_collections_abc
 try:
    import collections.abc as compat_collections_abc
 except ImportError:
    import collections as compat_collections_abc

+
+# compat_urllib_request
 try:
    import urllib.request as compat_urllib_request
 except ImportError:  # Python 2
@ -79,11 +87,15 @@ except TypeError:
    _add_init_method_arg(compat_urllib_request.Request)
    del _add_init_method_arg

+
+# compat_urllib_error
 try:
    import urllib.error as compat_urllib_error
 except ImportError:  # Python 2
    import urllib2 as compat_urllib_error

+
+# compat_urllib_parse
 try:
    import urllib.parse as compat_urllib_parse
 except ImportError:  # Python 2
@ -98,17 +110,23 @@ except ImportError:  # Python 2
 compat_urlparse = compat_urllib_parse
 compat_urllib_parse_urlparse = compat_urllib_parse.urlparse

+
+# compat_urllib_response
 try:
    import urllib.response as compat_urllib_response
 except ImportError:  # Python 2
    import urllib as compat_urllib_response

+
+# compat_urllib_response.addinfourl
 try:
    compat_urllib_response.addinfourl.status
 except AttributeError:
    # .getcode() is deprecated in Py 3.
    compat_urllib_response.addinfourl.status = property(lambda self: self.getcode())

+
+# compat_http_cookiejar
 try:
    import http.cookiejar as compat_cookiejar
 except ImportError:  # Python 2
@ -127,12 +145,16 @@ else:
    compat_cookiejar_Cookie = compat_cookiejar.Cookie
 compat_http_cookiejar_Cookie = compat_cookiejar_Cookie

+
+# compat_http_cookies
 try:
    import http.cookies as compat_cookies
 except ImportError:  # Python 2
    import Cookie as compat_cookies
 compat_http_cookies = compat_cookies

+
+# compat_http_cookies_SimpleCookie
 if sys.version_info[0] == 2 or sys.version_info < (3, 3):
    class compat_cookies_SimpleCookie(compat_cookies.SimpleCookie):
        def load(self, rawdata):
@ -155,11 +177,15 @@ else:
    compat_cookies_SimpleCookie = compat_cookies.SimpleCookie
 compat_http_cookies_SimpleCookie = compat_cookies_SimpleCookie

+
+# compat_html_entities, probably useless now
 try:
    import html.entities as compat_html_entities
 except ImportError:  # Python 2
    import htmlentitydefs as compat_html_entities

+
+# compat_html_entities_html5
 try:  # Python >= 3.3
    compat_html_entities_html5 = compat_html_entities.html5
 except AttributeError:
@ -2408,18 +2434,24 @@ except AttributeError:
    # Py < 3.1
    compat_http_client.HTTPResponse.getcode = lambda self: self.status

+
+# compat_urllib_HTTPError
 try:
    from urllib.error import HTTPError as compat_HTTPError
 except ImportError:  # Python 2
    from urllib2 import HTTPError as compat_HTTPError
 compat_urllib_HTTPError = compat_HTTPError

+
+# compat_urllib_request_urlretrieve
 try:
    from urllib.request import urlretrieve as compat_urlretrieve
 except ImportError:  # Python 2
    from urllib import urlretrieve as compat_urlretrieve
 compat_urllib_request_urlretrieve = compat_urlretrieve

+
+# compat_html_parser_HTMLParser, compat_html_parser_HTMLParseError
 try:
    from HTMLParser import (
        HTMLParser as compat_HTMLParser,
@ -2432,22 +2464,33 @@ except ImportError:  # Python 3
        # HTMLParseError was deprecated in Python 3.3 and removed in
        # Python 3.5. Introducing dummy exception for Python >3.5 for compatible
        # and uniform cross-version exception handling
+
        class compat_HTMLParseError(Exception):
            pass
+
 compat_html_parser_HTMLParser = compat_HTMLParser
 compat_html_parser_HTMLParseError = compat_HTMLParseError

+
+# compat_subprocess_get_DEVNULL
 try:
    _DEVNULL = subprocess.DEVNULL
    compat_subprocess_get_DEVNULL = lambda: _DEVNULL
 except AttributeError:
    compat_subprocess_get_DEVNULL = lambda: open(os.path.devnull, 'w')

+
+# compat_http_server
 try:
    import http.server as compat_http_server
 except ImportError:
    import BaseHTTPServer as compat_http_server

+
+# compat_urllib_parse_unquote_to_bytes,
+# compat_urllib_parse_unquote, compat_urllib_parse_unquote_plus,
+# compat_urllib_parse_urlencode,
+# compat_urllib_parse_parse_qs
 try:
    from urllib.parse import unquote_to_bytes as compat_urllib_parse_unquote_to_bytes
    from urllib.parse import unquote as compat_urllib_parse_unquote
@ -2598,6 +2641,8 @@ except ImportError:  # Python 2

 compat_urllib_parse_parse_qs = compat_parse_qs

+
+# compat_urllib_request_DataHandler
 try:
    from urllib.request import DataHandler as compat_urllib_request_DataHandler
 except ImportError:  # Python < 3.4
@ -2632,16 +2677,20 @@ except ImportError:  # Python < 3.4

            return compat_urllib_response.addinfourl(io.BytesIO(data), headers, url)

+
+# compat_xml_etree_ElementTree_ParseError
 try:
    from xml.etree.ElementTree import ParseError as compat_xml_parse_error
 except ImportError:  # Python 2.6
    from xml.parsers.expat import ExpatError as compat_xml_parse_error
 compat_xml_etree_ElementTree_ParseError = compat_xml_parse_error

-etree = xml.etree.ElementTree
+
+# compat_xml_etree_ElementTree_Element
+_etree = xml.etree.ElementTree


-class _TreeBuilder(etree.TreeBuilder):
+class _TreeBuilder(_etree.TreeBuilder):
    def doctype(self, name, pubid, system):
        pass

@ -2650,7 +2699,7 @@ try:
    # xml.etree.ElementTree.Element is a method in Python <=2.6 and
    # the following will crash with:
    #  TypeError: isinstance() arg 2 must be a class, type, or tuple of classes and types
-    isinstance(None, etree.Element)
+    isinstance(None, _etree.Element)
    from xml.etree.ElementTree import Element as compat_etree_Element
 except TypeError:  # Python <=2.6
    from xml.etree.ElementTree import _ElementInterface as compat_etree_Element
@ -2658,12 +2707,12 @@ compat_xml_etree_ElementTree_Element = compat_etree_Element

 if sys.version_info[0] >= 3:
    def compat_etree_fromstring(text):
-        return etree.XML(text, parser=etree.XMLParser(target=_TreeBuilder()))
+        return _etree.XML(text, parser=_etree.XMLParser(target=_TreeBuilder()))
 else:
    # python 2.x tries to encode unicode strings with ascii (see the
    # XMLParser._fixtext method)
    try:
-        _etree_iter = etree.Element.iter
+        _etree_iter = _etree.Element.iter
    except AttributeError:  # Python <=2.6
        def _etree_iter(root):
            for el in root.findall('*'):
@ -2675,27 +2724,29 @@ else:
    # 2.7 source
    def _XML(text, parser=None):
        if not parser:
-            parser = etree.XMLParser(target=_TreeBuilder())
+            parser = _etree.XMLParser(target=_TreeBuilder())
        parser.feed(text)
        return parser.close()

    def _element_factory(*args, **kwargs):
-        el = etree.Element(*args, **kwargs)
+        el = _etree.Element(*args, **kwargs)
        for k, v in el.items():
            if isinstance(v, bytes):
                el.set(k, v.decode('utf-8'))
        return el

    def compat_etree_fromstring(text):
-        doc = _XML(text, parser=etree.XMLParser(target=_TreeBuilder(element_factory=_element_factory)))
+        doc = _XML(text, parser=_etree.XMLParser(target=_TreeBuilder(element_factory=_element_factory)))
        for el in _etree_iter(doc):
            if el.text is not None and isinstance(el.text, bytes):
                el.text = el.text.decode('utf-8')
        return doc

-if hasattr(etree, 'register_namespace'):
-    compat_etree_register_namespace = etree.register_namespace
-else:
+
+# compat_xml_etree_register_namespace
+try:
+    compat_etree_register_namespace = _etree.register_namespace
+except AttributeError:
    def compat_etree_register_namespace(prefix, uri):
        """Register a namespace prefix.
        The registry is global, and any existing mapping for either the
@ -2704,14 +2755,16 @@ else:
        attributes in this namespace will be serialized with prefix if possible.
        ValueError is raised if prefix is reserved or is invalid.
        """
-        if re.match(r"ns\d+$", prefix):
-            raise ValueError("Prefix format reserved for internal use")
-        for k, v in list(etree._namespace_map.items()):
+        if re.match(r'ns\d+$', prefix):
+            raise ValueError('Prefix format reserved for internal use')
+        for k, v in list(_etree._namespace_map.items()):
            if k == uri or v == prefix:
-                del etree._namespace_map[k]
-        etree._namespace_map[uri] = prefix
+                del _etree._namespace_map[k]
+        _etree._namespace_map[uri] = prefix
 compat_xml_etree_register_namespace = compat_etree_register_namespace

+
+# compat_xpath, compat_etree_iterfind
 if sys.version_info < (2, 7):
    # Here comes the crazy part: In 2.6, if the xpath is a unicode,
    # .//node does not match if a node is a direct child of . !
@ -2898,7 +2951,6 @@ if sys.version_info < (2, 7):
        def __init__(self, root):
            self.root = root

-    ##
    # Generate all matching objects.

    def compat_etree_iterfind(elem, path, namespaces=None):
@ -2933,13 +2985,15 @@ if sys.version_info < (2, 7):


 else:
-    compat_xpath = lambda xpath: xpath
    compat_etree_iterfind = lambda element, match: element.iterfind(match)
+    compat_xpath = _IDENTITY


+# compat_os_name
 compat_os_name = os._name if os.name == 'java' else os.name


+# compat_shlex_quote
 if compat_os_name == 'nt':
    def compat_shlex_quote(s):
        return s if re.match(r'^[-_\w./]+$', s) else '"%s"' % s.replace('"', '\\"')
@ -2954,6 +3008,7 @@ else:
                return "'" + s.replace("'", "'\"'\"'") + "'"


+# compat_shlex.split
 try:
    args = shlex.split('中文')
    assert (isinstance(args, list)
@ -2969,6 +3024,7 @@ except (AssertionError, UnicodeEncodeError):
        return list(map(lambda s: s.decode('utf-8'), shlex.split(s, comments, posix)))


+# compat_ord
 def compat_ord(c):
    if isinstance(c, int):
        return c
@ -2976,6 +3032,7 @@ def compat_ord(c):
        return ord(c)


+# compat_getenv, compat_os_path_expanduser, compat_setenv
 if sys.version_info >= (3, 0):
    compat_getenv = os.getenv
    compat_expanduser = os.path.expanduser
@ -3063,6 +3120,7 @@ else:
 compat_os_path_expanduser = compat_expanduser


+# compat_os_path_realpath
 if compat_os_name == 'nt' and sys.version_info < (3, 8):
    # os.path.realpath on Windows does not follow symbolic links
    # prior to Python 3.8 (see https://bugs.python.org/issue9949)
@ -3076,6 +3134,7 @@ else:
 compat_os_path_realpath = compat_realpath


+# compat_print
 if sys.version_info < (3, 0):
    def compat_print(s):
        from .utils import preferredencoding
@ -3086,6 +3145,7 @@ else:
        print(s)


+# compat_getpass_getpass
 if sys.version_info < (3, 0) and sys.platform == 'win32':
    def compat_getpass(prompt, *args, **kwargs):
        if isinstance(prompt, compat_str):
@ -3098,22 +3158,22 @@ else:
 compat_getpass_getpass = compat_getpass


+# compat_input
 try:
    compat_input = raw_input
 except NameError:  # Python 3
    compat_input = input


+# compat_kwargs
 # Python < 2.6.5 require kwargs to be bytes
 try:
-    def _testfunc(x):
-        pass
-    _testfunc(**{'x': 0})
+    (lambda x: x)(**{'x': 0})
 except TypeError:
    def compat_kwargs(kwargs):
        return dict((bytes(k), v) for k, v in kwargs.items())
 else:
-    compat_kwargs = lambda kwargs: kwargs
+    compat_kwargs = _IDENTITY


 # compat_numeric_types
@ -3132,6 +3192,8 @@ except NameError:  # Python 3
 # compat_int
 compat_int = compat_integer_types[-1]

+
+# compat_socket_create_connection
 if sys.version_info < (2, 7):
    def compat_socket_create_connection(address, timeout, source_address=None):
        host, port = address
@ -3158,6 +3220,7 @@ else:
    compat_socket_create_connection = socket.create_connection


+# compat_contextlib_suppress
 try:
    from contextlib import suppress as compat_contextlib_suppress
 except ImportError:
@ -3200,12 +3263,12 @@ except AttributeError:
                        # repeated .close() is OK, but just in case
                        with compat_contextlib_suppress(EnvironmentError):
                            f.close()
-                popen.wait()
+            popen.wait()


 # Fix https://github.com/ytdl-org/youtube-dl/issues/4223
 # See http://bugs.python.org/issue9161 for what is broken
-def workaround_optparse_bug9161():
+def _workaround_optparse_bug9161():
    op = optparse.OptionParser()
    og = optparse.OptionGroup(op, 'foo')
    try:
@ -3224,9 +3287,10 @@ def workaround_optparse_bug9161():
        optparse.OptionGroup.add_option = _compat_add_option


-if hasattr(shutil, 'get_terminal_size'):  # Python >= 3.3
-    compat_get_terminal_size = shutil.get_terminal_size
-else:
+# compat_shutil_get_terminal_size
+try:
+    from shutil import get_terminal_size as compat_get_terminal_size  # Python >= 3.3
+except ImportError:
    _terminal_size = collections.namedtuple('terminal_size', ['columns', 'lines'])

    def compat_get_terminal_size(fallback=(80, 24)):
@ -3256,27 +3320,33 @@ else:
                columns = _columns
            if lines is None or lines <= 0:
                lines = _lines
+
        return _terminal_size(columns, lines)

+compat_shutil_get_terminal_size = compat_get_terminal_size

+
+# compat_itertools_count
 try:
-    itertools.count(start=0, step=1)
+    type(itertools.count(start=0, step=1))
    compat_itertools_count = itertools.count
-except TypeError:  # Python 2.6
+except TypeError:  # Python 2.6 lacks step
    def compat_itertools_count(start=0, step=1):
        while True:
            yield start
            start += step


+# compat_tokenize_tokenize
 if sys.version_info >= (3, 0):
    from tokenize import tokenize as compat_tokenize_tokenize
 else:
    from tokenize import generate_tokens as compat_tokenize_tokenize


+# compat_struct_pack, compat_struct_unpack, compat_Struct
 try:
-    struct.pack('!I', 0)
+    type(struct.pack('!I', 0))
 except TypeError:
    # In Python 2.6 and 2.7.x < 2.7.7, struct requires a bytes argument
    # See https://bugs.python.org/issue19099
@ -3308,8 +3378,10 @@ else:
        compat_Struct = struct.Struct


-# compat_map/filter() returning an iterator, supposedly the
-# same versioning as for zip below
+# builtins returning an iterator
+
+# compat_map, compat_filter
+# supposedly the same versioning as for zip below
 try:
    from future_builtins import map as compat_map
 except ImportError:
@ -3326,6 +3398,7 @@ except ImportError:
    except ImportError:
        compat_filter = filter

+# compat_zip
 try:
    from future_builtins import zip as compat_zip
 except ImportError:  # not 2.6+ or is 3.x
@ -3335,6 +3408,7 @@ except ImportError:  # not 2.6+ or is 3.x
        compat_zip = zip


+# compat_itertools_zip_longest
 # method renamed between Py2/3
 try:
    from itertools import zip_longest as compat_itertools_zip_longest
@ -3342,7 +3416,8 @@ except ImportError:
    from itertools import izip_longest as compat_itertools_zip_longest


-# new class in collections
+# compat_collections_chain_map
+# collections.ChainMap: new class
 try:
    from collections import ChainMap as compat_collections_chain_map
    # Py3.3's ChainMap is deficient
@ -3398,19 +3473,22 @@ except ImportError:
        def new_child(self, m=None, **kwargs):
            m = m or {}
            m.update(kwargs)
-            return compat_collections_chain_map(m, *self.maps)
+            # support inheritance !
+            return type(self)(m, *self.maps)

        @property
        def parents(self):
-            return compat_collections_chain_map(*(self.maps[1:]))
+            return type(self)(*(self.maps[1:]))


+# compat_re_Pattern, compat_re_Match
 # Pythons disagree on the type of a pattern (RegexObject, _sre.SRE_Pattern, Pattern, ...?)
 compat_re_Pattern = type(re.compile(''))
 # and on the type of a match
 compat_re_Match = type(re.match('a', 'a'))


+# compat_base64_b64decode
 if sys.version_info < (3, 3):
    def compat_b64decode(s, *args, **kwargs):
        if isinstance(s, compat_str):
@ -3422,6 +3500,7 @@ else:
 compat_base64_b64decode = compat_b64decode


+# compat_ctypes_WINFUNCTYPE
 if platform.python_implementation() == 'PyPy' and sys.pypy_version_info < (5, 4, 0):
    # PyPy2 prior to version 5.4.0 expects byte strings as Windows function
    # names, see the original PyPy issue [1] and the youtube-dl one [2].
@ -3440,6 +3519,7 @@ else:
        return ctypes.WINFUNCTYPE(*args, **kwargs)


+# compat_open
 if sys.version_info < (3, 0):
    # open(file, mode='r', buffering=- 1, encoding=None, errors=None, newline=None, closefd=True) not: opener=None
    def compat_open(file_, *args, **kwargs):
@ -3467,18 +3547,28 @@ except AttributeError:
    def compat_datetime_timedelta_total_seconds(td):
        return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6

+
 # optional decompression packages
+# compat_brotli
 # PyPi brotli package implements 'br' Content-Encoding
 try:
    import brotli as compat_brotli
 except ImportError:
    compat_brotli = None
+# compat_ncompress
 # PyPi ncompress package implements 'compress' Content-Encoding
 try:
    import ncompress as compat_ncompress
 except ImportError:
    compat_ncompress = None

+# compat_zstandard
+# PyPi zstandard package implements 'zstd' Content-Encoding (RFC 8878 7.2)
+try:
+    import zstandard as compat_zstandard
+except ImportError:
+    compat_zstandard = None
+

 legacy = [
    'compat_HTMLParseError',
@ -3495,6 +3585,7 @@ legacy = [
    'compat_getpass',
    'compat_parse_qs',
    'compat_realpath',
+    'compat_shlex_split',
    'compat_urllib_parse_parse_qs',
    'compat_urllib_parse_unquote',
    'compat_urllib_parse_unquote_plus',
@ -3508,8 +3599,6 @@ legacy = [


 __all__ = [
-    'compat_html_parser_HTMLParseError',
-    'compat_html_parser_HTMLParser',
    'compat_Struct',
    'compat_base64_b64decode',
    'compat_basestring',
@ -3518,13 +3607,9 @@ __all__ = [
    'compat_chr',
    'compat_collections_abc',
    'compat_collections_chain_map',
-    'compat_datetime_timedelta_total_seconds',
-    'compat_http_cookiejar',
-    'compat_http_cookiejar_Cookie',
-    'compat_http_cookies',
-    'compat_http_cookies_SimpleCookie',
    'compat_contextlib_suppress',
    'compat_ctypes_WINFUNCTYPE',
+    'compat_datetime_timedelta_total_seconds',
    'compat_etree_fromstring',
    'compat_etree_iterfind',
    'compat_filter',
@ -3533,6 +3618,12 @@ __all__ = [
    'compat_getpass_getpass',
    'compat_html_entities',
    'compat_html_entities_html5',
+    'compat_html_parser_HTMLParseError',
+    'compat_html_parser_HTMLParser',
+    'compat_http_cookiejar',
+    'compat_http_cookiejar_Cookie',
+    'compat_http_cookies',
+    'compat_http_cookies_SimpleCookie',
    'compat_http_client',
    'compat_http_server',
    'compat_input',
@ -3555,7 +3646,7 @@ __all__ = [
    'compat_register_utf8',
    'compat_setenv',
    'compat_shlex_quote',
-    'compat_shlex_split',
+    'compat_shutil_get_terminal_size',
    'compat_socket_create_connection',
    'compat_str',
    'compat_struct_pack',
@ -3575,5 +3666,5 @@ __all__ = [
    'compat_xml_etree_register_namespace',
    'compat_xpath',
    'compat_zip',
-    'workaround_optparse_bug9161',
+    'compat_zstandard',
 ]
--- a/youtube_dl/extractor/art19.py
+++ b/youtube_dl/extractor/art19.py
@ -0,0 +1,315 @@
+# coding: utf-8
+from __future__ import unicode_literals
+
+import re
+
+from .common import InfoExtractor
+from ..utils import (
+    ExtractorError,
+    float_or_none,
+    int_or_none,
+    merge_dicts,
+    parse_iso8601,
+    str_or_none,
+    T,
+    traverse_obj,
+    url_or_none,
+)
+
+
+class Art19IE(InfoExtractor):
+    _UUID_REGEX = r'[\da-f]{8}-?[\da-f]{4}-?[\da-f]{4}-?[\da-f]{4}-?[\da-f]{12}'
+    _VALID_URL = (
+        r'https?://(?:www\.)?art19\.com/shows/[^/#?]+/episodes/(?P<id>{0})'.format(_UUID_REGEX),
+        r'https?://rss\.art19\.com/episodes/(?P<id>{0})\.mp3'.format(_UUID_REGEX),
+    )
+    _EMBED_REGEX = (r'<iframe\b[^>]+\bsrc\s*=\s*[\'"](?P<url>{0})'.format(_VALID_URL[0]),)
+
+    _TESTS = [{
+        'url': 'https://rss.art19.com/episodes/5ba1413c-48b8-472b-9cc3-cfd952340bdb.mp3',
+        'info_dict': {
+            'id': '5ba1413c-48b8-472b-9cc3-cfd952340bdb',
+            'ext': 'mp3',
+            'title': 'Why Did DeSantis Drop Out?',
+            'series': 'The Daily Briefing',
+            'release_timestamp': 1705941275,
+            'description': 'md5:da38961da4a3f7e419471365e3c6b49f',
+            'episode': 'Episode 582',
+            'thumbnail': r're:^https?://content\.production\.cdn\.art19\.com.*\.jpeg$',
+            'series_id': 'ed52a0ab-08b1-4def-8afc-549e4d93296d',
+            'upload_date': '20240122',
+            'timestamp': 1705940815,
+            'episode_number': 582,
+            # 'modified_date': '20240122',
+            'episode_id': '5ba1413c-48b8-472b-9cc3-cfd952340bdb',
+            'modified_timestamp': int,
+            'release_date': '20240122',
+            'duration': 527.4,
+        },
+    }, {
+        'url': 'https://art19.com/shows/scamfluencers/episodes/8319b776-4153-4d22-8630-631f204a03dd',
+        'info_dict': {
+            'id': '8319b776-4153-4d22-8630-631f204a03dd',
+            'ext': 'mp3',
+            'title': 'Martha Stewart: The Homemaker Hustler Part 2',
+            # 'modified_date': '20240116',
+            'upload_date': '20240105',
+            'modified_timestamp': int,
+            'episode_id': '8319b776-4153-4d22-8630-631f204a03dd',
+            'series_id': 'd3c9b8ca-26b3-42f4-9bd8-21d1a9031e75',
+            'thumbnail': r're:^https?://content\.production\.cdn\.art19\.com.*\.jpeg$',
+            'description': r're:(?s)In the summer of 2003, Martha Stewart is indicted .{695}#do-not-sell-my-info\.$',
+            'release_timestamp': 1705305660,
+            'release_date': '20240115',
+            'timestamp': 1704481536,
+            'episode_number': 88,
+            'series': 'Scamfluencers',
+            'duration': 2588.37501,
+            'episode': 'Episode 88',
+        },
+    }]
+    _WEBPAGE_TESTS = [{
+        'url': 'https://www.nu.nl/formule-1/6291456/verstappen-wordt-een-synoniem-voor-formule-1.html',
+        'info_dict': {
+            'id': '7d42626a-7301-47db-bb8a-3b6f054d77d7',
+            'ext': 'mp3',
+            'title': "'Verstappen wordt een synoniem voor Formule 1'",
+            'season': 'Seizoen 6',
+            'description': 'md5:39a7159a31c4cda312b2e893bdd5c071',
+            'episode_id': '7d42626a-7301-47db-bb8a-3b6f054d77d7',
+            'duration': 3061.82111,
+            'series_id': '93f4e113-2a60-4609-a564-755058fa40d8',
+            'release_date': '20231126',
+            'modified_timestamp': 1701156004,
+            'thumbnail': r're:^https?://content\.production\.cdn\.art19\.com.*\.jpeg$',
+            'season_number': 6,
+            'episode_number': 52,
+            # 'modified_date': '20231128',
+            'upload_date': '20231126',
+            'timestamp': 1701025981,
+            'season_id': '36097c1e-7455-490d-a2fe-e2f10b4d5f26',
+            'series': 'De Boordradio',
+            'release_timestamp': 1701026308,
+            'episode': 'Episode 52',
+        },
+    }, {
+        'url': 'https://www.wishtv.com/podcast-episode/larry-bucshon-announces-retirement-from-congress/',
+        'info_dict': {
+            'id': '8da368bd-08d1-46d0-afaa-c134a4af7dc0',
+            'ext': 'mp3',
+            'title': 'Larry Bucshon announces retirement from congress',
+            'upload_date': '20240115',
+            'episode_number': 148,
+            'episode': 'Episode 148',
+            'thumbnail': r're:^https?://content\.production\.cdn\.art19\.com.*\.jpeg$',
+            'release_date': '20240115',
+            'timestamp': 1705328205,
+            'release_timestamp': 1705329275,
+            'series': 'All INdiana Politics',
+            # 'modified_date': '20240117',
+            'modified_timestamp': 1705458901,
+            'series_id': 'c4af6c27-b10f-4ff2-9f84-0f407df86ff1',
+            'episode_id': '8da368bd-08d1-46d0-afaa-c134a4af7dc0',
+            'description': 'md5:53b5239e4d14973a87125c217c255b2a',
+            'duration': 1256.18848,
+        },
+    }]
+
+    @classmethod
+    def _extract_embed_urls(cls, url, webpage):
+        for from_ in super(Art19IE, cls)._extract_embed_urls(url, webpage):
+            yield from_
+        for episode_id in re.findall(
+                r'<div\b[^>]+\bclass\s*=\s*[\'"][^\'"]*art19-web-player[^\'"]*[\'"][^>]+\bdata-episode-id=[\'"]({0})[\'"]'.format(cls._UUID_REGEX), webpage):
+            yield 'https://rss.art19.com/episodes/{0}.mp3'.format(episode_id)
+
+    def _real_extract(self, url):
+        episode_id = self._match_id(url)
+
+        player_metadata = self._download_json(
+            'https://art19.com/episodes/{0}'.format(episode_id), episode_id,
+            note='Downloading player metadata', fatal=False,
+            headers={'Accept': 'application/vnd.art19.v0+json'})
+        rss_metadata = self._download_json(
+            'https://rss.art19.com/episodes/{0}.json'.format(episode_id), episode_id,
+            fatal=False, note='Downloading RSS metadata')
+
+        formats = [{
+            'format_id': 'direct',
+            'url': 'https://rss.art19.com/episodes/{0}.mp3'.format(episode_id),
+            'vcodec': 'none',
+            'acodec': 'mp3',
+        }]
+        for fmt_id, fmt_data in traverse_obj(rss_metadata, (
+                'content', 'media', T(dict.items),
+                lambda _, k_v: k_v[0] != 'waveform_bin' and k_v[1].get('url'))):
+            fmt_url = url_or_none(fmt_data['url'])
+            if not fmt_url:
+                continue
+            formats.append({
+                'format_id': fmt_id,
+                'url': fmt_url,
+                'vcodec': 'none',
+                'acodec': fmt_id,
+                'quality': -2 if fmt_id == 'ogg' else -1,
+            })
+
+        self._sort_formats(formats)
+
+        return merge_dicts({
+            'id': episode_id,
+            'formats': formats,
+        }, traverse_obj(player_metadata, ('episode', {
+            'title': ('title', T(str_or_none)),
+            'description': ('description_plain', T(str_or_none)),
+            'episode_id': ('id', T(str_or_none)),
+            'episode_number': ('episode_number', T(int_or_none)),
+            'season_id': ('season_id', T(str_or_none)),
+            'series_id': ('series_id', T(str_or_none)),
+            'timestamp': ('created_at', T(parse_iso8601)),
+            'release_timestamp': ('released_at', T(parse_iso8601)),
+            'modified_timestamp': ('updated_at', T(parse_iso8601)),
+        })), traverse_obj(rss_metadata, ('content', {
+            'title': ('episode_title', T(str_or_none)),
+            'description': ('episode_description_plain', T(str_or_none)),
+            'episode_id': ('episode_id', T(str_or_none)),
+            'episode_number': ('episode_number', T(int_or_none)),
+            'season': ('season_title', T(str_or_none)),
+            'season_id': ('season_id', T(str_or_none)),
+            'season_number': ('season_number', T(int_or_none)),
+            'series': ('series_title', T(str_or_none)),
+            'series_id': ('series_id', T(str_or_none)),
+            'thumbnail': ('cover_image', T(url_or_none)),
+            'duration': ('duration', T(float_or_none)),
+        })), rev=True)
+
+
+class Art19ShowIE(InfoExtractor):
+    IE_DESC = 'Art19 series'
+    _VALID_URL_BASE = r'https?://(?:www\.)?art19\.com/shows/(?P<id>[\w-]+)(?:/embed)?/?'
+    _VALID_URL = (
+        r'{0}(?:$|[#?])'.format(_VALID_URL_BASE),
+        r'https?://rss\.art19\.com/(?P<id>[\w-]+)/?(?:$|[#?])',
+    )
+    _EMBED_REGEX = (r'<iframe[^>]+\bsrc=[\'"](?P<url>{0}[^\'"])'.format(_VALID_URL_BASE),)
+
+    _TESTS = [{
+        'url': 'https://www.art19.com/shows/5898c087-a14f-48dc-b6fc-a2280a1ff6e0/',
+        'info_dict': {
+            '_type': 'playlist',
+            'id': '5898c087-a14f-48dc-b6fc-a2280a1ff6e0',
+            'display_id': 'echt-gebeurd',
+            'title': 'Echt Gebeurd',
+            'description': r're:(?us)Bij\sEcht Gebeurd\svertellen mensen .{1166} Eline Veldhuisen\.$',
+            'timestamp': 1492642167,
+            # 'upload_date': '20170419',
+            'modified_timestamp': int,
+            # 'modified_date': str,
+            'tags': 'count:7',
+        },
+        'playlist_mincount': 425,
+    }, {
+        'url': 'https://rss.art19.com/scamfluencers',
+        'info_dict': {
+            '_type': 'playlist',
+            'id': 'd3c9b8ca-26b3-42f4-9bd8-21d1a9031e75',
+            'display_id': 'scamfluencers',
+            'title': 'Scamfluencers',
+            'description': r're:(?s)You never really know someone\b.{1078} wondery\.com/links/scamfluencers/ now\.$',
+            'timestamp': 1647368573,
+            # 'upload_date': '20220315',
+            'modified_timestamp': int,
+            # 'modified_date': str,
+            'tags': [],
+        },
+        'playlist_mincount': 90,
+    }, {
+        'url': 'https://art19.com/shows/enthuellt/embed',
+        'info_dict': {
+            '_type': 'playlist',
+            'id': 'e2cacf57-bb8a-4263-aa81-719bcdd4f80c',
+            'display_id': 'enthuellt',
+            'title': 'Enthüllt',
+            'description': 'md5:17752246643414a2fd51744fc9a1c08e',
+            'timestamp': 1601645860,
+            # 'upload_date': '20201002',
+            'modified_timestamp': int,
+            # 'modified_date': str,
+            'tags': 'count:10',
+        },
+        'playlist_mincount': 10,
+        'skip': 'Content not found',
+    }]
+    _WEBPAGE_TESTS = [{
+        'url': 'https://deconstructingyourself.com/deconstructing-yourself-podcast',
+        'info_dict': {
+            '_type': 'playlist',
+            'id': 'cfbb9b01-c295-4adb-8726-adde7c03cf21',
+            'display_id': 'deconstructing-yourself',
+            'title': 'Deconstructing Yourself',
+            'description': 'md5:dab5082b28b248a35476abf64768854d',
+            'timestamp': 1570581181,
+            # 'upload_date': '20191009',
+            'modified_timestamp': int,
+            # 'modified_date': str,
+            'tags': 'count:5',
+        },
+        'playlist_mincount': 80,
+    }, {
+        'url': 'https://chicagoreader.com/columns-opinion/podcasts/ben-joravsky-show-podcast-episodes/',
+        'info_dict': {
+            '_type': 'playlist',
+            'id': '9dfa2c37-ab87-4c13-8388-4897914313ec',
+            'display_id': 'the-ben-joravsky-show',
+            'title': 'The Ben Joravsky Show',
+            'description': 'md5:c0f3ec0ee0dbea764390e521adc8780a',
+            'timestamp': 1550875095,
+            # 'upload_date': '20190222',
+            'modified_timestamp': int,
+            # 'modified_date': str,
+            'tags': ['Chicago Politics', 'chicago', 'Ben Joravsky'],
+        },
+        'playlist_mincount': 1900,
+    }]
+
+    @classmethod
+    def _extract_embed_urls(cls, url, webpage):
+        for from_ in super(Art19ShowIE, cls)._extract_embed_urls(url, webpage):
+            yield from_
+        for series_id in re.findall(
+                r'<div[^>]+\bclass=[\'"][^\'"]*art19-web-player[^\'"]*[\'"][^>]+\bdata-series-id=[\'"]([\w-]+)[\'"]', webpage):
+            yield 'https://art19.com/shows/{0}'.format(series_id)
+
+    def _real_extract(self, url):
+        series_id = self._match_id(url)
+        for expected in ((403, 404), None):
+            series_metadata, urlh = self._download_json_handle(
+                'https://art19.com/series/{0}'.format(series_id), series_id, note='Downloading series metadata',
+                headers={'Accept': 'application/vnd.art19.v0+json'},
+                expected_status=(403, 404))
+            if urlh.getcode() == 403:
+                # raise the actual problem with the page
+                urlh = self._request_webpage(url, series_id, expected_status=404)
+                if urlh.getcode() == 404:
+                    raise ExtractorError(
+                        'content not found, possibly expired',
+                        video_id=series_id, expected=True)
+            if urlh.getcode() not in (expected or []):
+                # apparently OK
+                break
+
+        return merge_dicts(
+            self.playlist_result((
+                self.url_result('https://rss.art19.com/episodes/{0}.mp3'.format(episode_id), Art19IE)
+                for episode_id in traverse_obj(series_metadata, ('series', 'episode_ids', Ellipsis, T(str_or_none))))),
+            traverse_obj(series_metadata, ('series', {
+                'id': ('id', T(str_or_none)),
+                'display_id': ('slug', T(str_or_none)),
+                'title': ('title', T(str_or_none)),
+                'description': ('description_plain', T(str_or_none)),
+                'timestamp': ('created_at', T(parse_iso8601)),
+                'modified_timestamp': ('updated_at', T(parse_iso8601)),
+            })),
+            traverse_obj(series_metadata, {
+                'tags': ('tags', Ellipsis, 'name', T(str_or_none)),
+            }, {'tags': T(lambda _: [])}))
--- a/youtube_dl/extractor/extractors.py
+++ b/youtube_dl/extractor/extractors.py
@ -71,13 +71,17 @@ from .ard import (
    ARDIE,
    ARDMediathekIE,
 )
+from .art19 import (
+    Art19IE,
+    Art19ShowIE,
+)
+from .arnes import ArnesIE
 from .arte import (
    ArteTVIE,
    ArteTVEmbedIE,
    ArteTVPlaylistIE,
    ArteTVCategoryIE,
 )
-from .arnes import ArnesIE
 from .asiancrush import (
    AsianCrushIE,
    AsianCrushPlaylistIE,
@ -776,7 +780,12 @@ from .ndr import (
    NJoyEmbedIE,
 )
 from .ndtv import NDTVIE
-from .netzkino import NetzkinoIE
+from .nebula import (
+    NebulaIE,
+    NebulaChannelIE,
+    NebulaClassIE,
+    NebulaSubscriptionsIE,
+)
 from .nerdcubed import NerdCubedFeedIE
 from .neteasemusic import (
    NetEaseMusicIE,
@ -787,6 +796,7 @@ from .neteasemusic import (
    NetEaseMusicProgramIE,
    NetEaseMusicDjRadioIE,
 )
+from .netzkino import NetzkinoIE
 from .newgrounds import (
    NewgroundsIE,
    NewgroundsPlaylistIE,
--- a/youtube_dl/extractor/nebula.py
+++ b/youtube_dl/extractor/nebula.py
@ -0,0 +1,574 @@
+# coding: utf-8
+from __future__ import unicode_literals
+
+import itertools
+
+from .art19 import Art19IE
+from .common import InfoExtractor
+from ..compat import (
+    compat_HTTPError as HTTPError,
+    compat_kwargs,
+    compat_str as str,
+)
+from ..utils import (
+    ExtractorError,
+    int_or_none,
+    json_stringify,
+    # make_archive_id,
+    merge_dicts,
+    parse_iso8601,
+    smuggle_url,
+    str_or_none,
+    T,
+    traverse_obj,
+    try_call,
+    unsmuggle_url,
+    update_url,
+    url_basename,
+    url_or_none,
+    urljoin,
+)
+
+_BASE_URL_RE = r'https?://(?:www\.|beta\.)?(?:watchnebula\.com|nebula\.app|nebula\.tv)'
+
+
+class NebulaBaseIE(InfoExtractor):
+    _NETRC_MACHINE = 'watchnebula'
+    _token = _api_token = None
+
+    def _real_initialize(self):
+        self._login()
+
+    def _login(self):
+        if not self._api_token:
+            self._api_token = try_call(
+                lambda: self._get_cookies('https://nebula.tv')['nebula_auth.apiToken'].value)
+        self._token = self._download_json(
+            'https://users.api.nebula.app/api/v1/authorization/', None,
+            headers={'Authorization': 'Token {0}'.format(self._api_token)} if self._api_token else {},
+            note='Authorizing to Nebula', data=b'')['token']
+        if self._token:
+            return
+
+        username, password = self._get_login_info()
+        if username is None:
+            return
+        self._perform_login(username, password)
+
+    def _perform_login(self, username, password):
+        try:
+            response = self._download_json(
+                'https://nebula.tv/auth/login/', None,
+                'Logging in to Nebula', 'Login failed',
+                data=json_stringify({'email': username, 'password': password}),
+                headers={'content-type': 'application/json'})
+        except ExtractorError as e:
+            if isinstance(e.cause, HTTPError) and e.cause.status == 400:
+                raise ExtractorError('Login failed: Invalid username or password', expected=True)
+            raise
+        self._api_token = traverse_obj(response, ('key', T(str)))
+        if not self._api_token:
+            raise ExtractorError('Login failed: No token')
+
+    def _call_api(self, *args, **kwargs):
+
+        def kwargs_set_token(kw):
+            kw.setdefault('headers', {})['Authorization'] = 'Bearer {0}'.format(self._token)
+            return compat_kwargs(kw)
+
+        if self._token:
+            kwargs = kwargs_set_token(kwargs)
+        try:
+            return self._download_json(*args, **kwargs)
+        except ExtractorError as e:
+            if not isinstance(e.cause, HTTPError) or e.cause.status not in (401, 403):
+                raise
+            self.to_screen(
+                'Reauthorizing with Nebula and retrying, because last API '
+                'call resulted in error {0}'.format(e.cause.status))
+            self._real_initialize()
+            if self._token:
+                kwargs = kwargs_set_token(kwargs)
+            return self._download_json(*args, **kwargs)
+
+    def _extract_formats(self, content_id, slug):
+        for retry in (False, True):
+            try:
+                # fmts, subs = self._extract_m3u8_formats_and_subtitles(
+                fmts, subs = self._extract_m3u8_formats(
+                    'https://content.api.nebula.app/{0}s/{1}/manifest.m3u8'.format(
+                        content_id.split(':', 1)[0], content_id),
+                    slug, 'mp4', query={
+                        'token': self._token,
+                        'app_version': '23.10.0',
+                        'platform': 'ios',
+                    }), {}
+                self._sort_formats(fmts)
+                return {'formats': fmts, 'subtitles': subs}
+            except ExtractorError as e:
+                if not isinstance(e.cause, HTTPError):
+                    raise
+                if e.cause.status == 401:
+                    self.raise_login_required()
+                if not retry and e.cause.status == 403:
+                    self.to_screen('Reauthorizing with Nebula and retrying, because fetching video resulted in error')
+                    self._real_initialize()
+                    continue
+                raise
+
+    def _extract_video_metadata(self, episode):
+        channel_url = traverse_obj(
+            episode, (('channel_slug', 'class_slug'), T(lambda u: urljoin('https://nebula.tv/', u))), get_all=False)
+        return merge_dicts({
+            'id': episode['id'].partition(':')[2],
+            'title': episode['title'],
+            'channel_url': channel_url,
+            'uploader_url': channel_url,
+        }, traverse_obj(episode, {
+            'display_id': 'slug',
+            'description': 'description',
+            'timestamp': ('published_at', T(parse_iso8601)),
+            'duration': ('duration', T(int_or_none)),
+            'channel_id': 'channel_slug',
+            'uploader_id': 'channel_slug',
+            'channel': 'channel_title',
+            'uploader': 'channel_title',
+            'series': 'channel_title',
+            'creator': 'channel_title',
+            'thumbnail': ('images', 'thumbnail', 'src', T(url_or_none)),
+            'episode_number': ('order', T(int_or_none)),
+
+            # Old code was wrongly setting extractor_key from NebulaSubscriptionsIE
+            # '_old_archive_ids': ('zype_id', {lambda x: [
+            #    make_archive_id(NebulaIE, x), make_archive_id(NebulaSubscriptionsIE, x)] if x else None}),
+        }))
+
+
+class NebulaIE(NebulaBaseIE):
+    IE_NAME = 'nebula:video'
+    _VALID_URL = r'{0}/videos/(?P<id>[\w-]+)'.format(_BASE_URL_RE)
+    _TESTS = [{
+        'url': 'https://nebula.tv/videos/that-time-disney-remade-beauty-and-the-beast',
+        'info_dict': {
+            'id': '84ed544d-4afd-4723-8cd5-2b95261f0abf',
+            'ext': 'mp4',
+            'title': 'That Time Disney Remade Beauty and the Beast',
+            'description': 'Note: this video was originally posted on YouTube with the sponsor read included. We weren’t able to remove it without reducing video quality, so it’s presented here in its original context.',
+            'upload_date': '20180731',
+            'timestamp': 1533009600,
+            'channel': 'Lindsay Ellis',
+            'channel_id': 'lindsayellis',
+            'uploader': 'Lindsay Ellis',
+            'uploader_id': 'lindsayellis',
+            'uploader_url': r're:https://nebula\.(tv|app)/lindsayellis',
+            'series': 'Lindsay Ellis',
+            'display_id': 'that-time-disney-remade-beauty-and-the-beast',
+            'channel_url': r're:https://nebula\.(tv|app)/lindsayellis',
+            'creator': 'Lindsay Ellis',
+            'duration': 2212,
+            'thumbnail': r're:https?://images\.nebula\.tv/[a-f\d-]+$',
+            # '_old_archive_ids': ['nebula 5c271b40b13fd613090034fd', 'nebulasubscriptions 5c271b40b13fd613090034fd'],
+        },
+        'params': {
+            'format': 'bestvideo',
+            'skip_download': 'm3u8',
+        },
+    }, {
+        'url': 'https://nebula.tv/videos/the-logistics-of-d-day-landing-craft-how-the-allies-got-ashore',
+        'md5': 'd05739cf6c38c09322422f696b569c23',
+        'info_dict': {
+            'id': '7e623145-1b44-4ca3-aa0b-ed25a247ea34',
+            'ext': 'mp4',
+            'title': 'Landing Craft - How The Allies Got Ashore',
+            'description': r're:^In this episode we explore the unsung heroes of D-Day, the landing craft.',
+            'upload_date': '20200327',
+            'timestamp': 1585348140,
+            'channel': 'Real Engineering — The Logistics of D-Day',
+            'channel_id': 'd-day',
+            'uploader': 'Real Engineering — The Logistics of D-Day',
+            'uploader_id': 'd-day',
+            'series': 'Real Engineering — The Logistics of D-Day',
+            'display_id': 'the-logistics-of-d-day-landing-craft-how-the-allies-got-ashore',
+            'creator': 'Real Engineering — The Logistics of D-Day',
+            'duration': 841,
+            'channel_url': 'https://nebula.tv/d-day',
+            'uploader_url': 'https://nebula.tv/d-day',
+            'thumbnail': r're:https?://images\.nebula\.tv/[a-f\d-]+$',
+            # '_old_archive_ids': ['nebula 5e7e78171aaf320001fbd6be', 'nebulasubscriptions 5e7e78171aaf320001fbd6be'],
+        },
+        'params': {
+            'format': 'bestvideo',
+            'skip_download': 'm3u8',
+        },
+        'skip': 'Only available for registered users',
+    }, {
+        'url': 'https://nebula.tv/videos/money-episode-1-the-draw',
+        'md5': 'ebe28a7ad822b9ee172387d860487868',
+        'info_dict': {
+            'id': 'b96c5714-9e2b-4ec3-b3f1-20f6e89cc553',
+            'ext': 'mp4',
+            'title': 'Episode 1: The Draw',
+            'description': r'contains:There’s free money on offer… if the players can all work together.',
+            'upload_date': '20200323',
+            'timestamp': 1584980400,
+            'channel': 'Tom Scott Presents: Money',
+            'channel_id': 'tom-scott-presents-money',
+            'uploader': 'Tom Scott Presents: Money',
+            'uploader_id': 'tom-scott-presents-money',
+            'uploader_url': 'https://nebula.tv/tom-scott-presents-money',
+            'duration': 825,
+            'channel_url': 'https://nebula.tv/tom-scott-presents-money',
+            'series': 'Tom Scott Presents: Money',
+            'display_id': 'money-episode-1-the-draw',
+            'thumbnail': r're:https?://images\.nebula\.tv/[a-f\d-]+$',
+            # '_old_archive_ids': ['nebula 5e779ebdd157bc0001d1c75a', 'nebulasubscriptions 5e779ebdd157bc0001d1c75a'],
+        },
+        'params': {
+            'format': 'bestvideo',
+            'skip_download': 'm3u8',
+        },
+        'skip': 'Only available for registered users',
+    }, {
+        'url': 'https://watchnebula.com/videos/money-episode-1-the-draw',
+        'only_matching': True,
+    }, {
+        'url': 'https://nebula.tv/videos/tldrnewseu-did-the-us-really-blow-up-the-nordstream-pipelines',
+        'info_dict': {
+            'id': 'e389af9d-1dab-44f2-8788-ee24deb7ff0d',
+            'ext': 'mp4',
+            'display_id': 'tldrnewseu-did-the-us-really-blow-up-the-nordstream-pipelines',
+            'title': 'Did the US Really Blow Up the NordStream Pipelines?',
+            'description': 'md5:b4e2a14e3ff08f546a3209c75261e789',
+            'upload_date': '20230223',
+            'timestamp': 1677144070,
+            'channel': 'TLDR News EU',
+            'channel_id': 'tldrnewseu',
+            'uploader': 'TLDR News EU',
+            'uploader_id': 'tldrnewseu',
+            'uploader_url': r're:https://nebula\.(tv|app)/tldrnewseu',
+            'duration': 524,
+            'channel_url': r're:https://nebula\.(tv|app)/tldrnewseu',
+            'series': 'TLDR News EU',
+            'thumbnail': r're:https?://images\.nebula\.tv/[a-f\d-]+$',
+            'creator': 'TLDR News EU',
+            # '_old_archive_ids': ['nebula 63f64c74366fcd00017c1513', 'nebulasubscriptions 63f64c74366fcd00017c1513'],
+        },
+        'params': {
+            'format': 'bestvideo',
+            'skip_download': 'm3u8',
+        },
+    }, {
+        'url': 'https://beta.nebula.tv/videos/money-episode-1-the-draw',
+        'only_matching': True,
+    }]
+
+    def _real_extract(self, url):
+        slug = self._match_id(url)
+        url, smuggled_data = unsmuggle_url(url, {})
+        if smuggled_data.get('id'):
+            return merge_dicts({
+                'id': smuggled_data['id'],
+                'display_id': slug,
+                'title': '',
+            }, self._extract_formats(smuggled_data['id'], slug))
+
+        metadata = self._call_api(
+            'https://content.api.nebula.app/content/videos/{0}'.format(slug),
+            slug, note='Fetching video metadata')
+        return merge_dicts(
+            self._extract_video_metadata(metadata),
+            self._extract_formats(metadata['id'], slug),
+            rev=True
+        )
+
+
+class NebulaClassIE(NebulaBaseIE):
+    IE_NAME = 'nebula:media'
+    _VALID_URL = r'{0}/(?!(?:myshows|library|videos)/)(?P<id>[\w-]+)/(?P<ep>[\w-]+)/?(?:$|[?#])'.format(_BASE_URL_RE)
+    _TESTS = [{
+        'url': 'https://nebula.tv/copyright-for-fun-and-profit/14',
+        'info_dict': {
+            'id': 'd7432cdc-c608-474d-942c-f74345daed7b',
+            'ext': 'mp4',
+            'display_id': '14',
+            'channel_url': 'https://nebula.tv/copyright-for-fun-and-profit',
+            'episode_number': 14,
+            'thumbnail': r're:https?://images\.nebula\.tv/[a-f\d-]+$',
+            'uploader_url': 'https://nebula.tv/copyright-for-fun-and-profit',
+            'duration': 646,
+            'episode': 'Episode 14',
+            'title': 'Photos, Sculpture, and Video',
+        },
+        'params': {
+            'format': 'bestvideo',
+            'skip_download': 'm3u8',
+        },
+        'skip': 'Only available for registered users',
+    }, {
+        'add_ies': [Art19IE],
+        'url': 'https://nebula.tv/extremitiespodcast/pyramiden-the-high-arctic-soviet-ghost-town',
+        'info_dict': {
+            'ext': 'mp3',
+            'id': '83ef3b53-049e-4211-b34e-7bb518e67d64',
+            'description': r"re:(?s)20 years ago, what was previously the Soviet Union's .{467}#do-not-sell-my-info\.$",
+            'series_id': 'e0223cfc-f39c-4ad4-8724-bd8731bd31b5',
+            'modified_timestamp': 1629410982,
+            'episode_id': '83ef3b53-049e-4211-b34e-7bb518e67d64',
+            'series': 'Extremities',
+            # 'modified_date': '20200903',
+            'upload_date': '20200902',
+            'title': 'Pyramiden: The High-Arctic Soviet Ghost Town',
+            'release_timestamp': 1571237958,
+            'thumbnail': r're:^https?://content\.production\.cdn\.art19\.com.*\.jpeg$',
+            'duration': 1546.05714,
+            'timestamp': 1599085555,
+            'release_date': '20191016',
+        },
+    }, {
+        'url': 'https://nebula.tv/thelayover/the-layover-episode-1',
+        'info_dict': {
+            'ext': 'mp3',
+            'id': '9d74a762-00bb-45a8-9e8d-9ed47c04a1d0',
+            'episode_number': 1,
+            'thumbnail': r're:https?://images\.nebula\.tv/[a-f\d-]+$',
+            'release_date': '20230304',
+            'modified_date': '20230403',
+            'series': 'The Layover',
+            'episode_id': '9d74a762-00bb-45a8-9e8d-9ed47c04a1d0',
+            'modified_timestamp': 1680554566,
+            'duration': 3130.46401,
+            'release_timestamp': 1677943800,
+            'title': 'The Layover — Episode 1',
+            'series_id': '874303a5-4900-4626-a4b6-2aacac34466a',
+            'upload_date': '20230303',
+            'episode': 'Episode 1',
+            'timestamp': 1677883672,
+            'description': 'md5:002cca89258e3bc7c268d5b8c24ba482',
+        },
+        'params': {
+            'format': 'bestvideo',
+            'skip_download': 'm3u8',
+        },
+        'skip': 'Only available for registered users',
+    }]
+
+    def _real_extract(self, url):
+        slug, episode = self._match_valid_url(url).group('id', 'ep')
+        url, smuggled_data = unsmuggle_url(url, {})
+        if smuggled_data.get('id'):
+            return merge_dicts({
+                'id': smuggled_data['id'],
+                'display_id': slug,
+                'title': '',
+            }, self._extract_formats(smuggled_data['id'], slug))
+
+        metadata = self._call_api(
+            'https://content.api.nebula.app/content/{0}/{1}/?include=lessons'.format(
+                slug, episode),
+            slug, note='Fetching class/podcast metadata')
+        content_type = traverse_obj(metadata, 'type')
+        if content_type == 'lesson':
+            return merge_dicts(
+                self._extract_video_metadata(metadata),
+                self._extract_formats(metadata['id'], slug))
+        elif content_type == 'podcast_episode':
+            episode_url = metadata.get('episode_url')
+            if not episode_url and metadata.get('premium'):
+                self.raise_login_required()
+
+            if Art19IE.suitable(episode_url):
+                return self.url_result(episode_url, Art19IE.ie_key())
+            return merge_dicts({
+                'id': metadata['id'],
+                'title': metadata['title'],
+            }, traverse_obj(metadata, {
+                'url': ('episode_url', T(url_or_none)),
+                'description': ('description', T(str_or_none)),
+                'timestamp': ('published_at', T(parse_iso8601)),
+                'duration': ('duration', T(int_or_none)),
+                'channel_id': ('channel_id', T(str_or_none)),
+                'channel': ('channel_title', T(str_or_none)),
+                'thumbnail': ('assets', 'regular', T(url_or_none)),
+            }))
+
+        raise ExtractorError('Unexpected content type {0!r}'.format(content_type))
+
+
+class NebulaPlaylistBaseIE(NebulaBaseIE):
+    _BASE_API_URL = 'https://content.api.nebula.app/'
+    _API_QUERY = {'ordering': '-published_at'}
+
+    @classmethod
+    def _get_api_url(cls, item_id, path='/video_episodes/'):
+        return update_url(cls._BASE_API_URL, path=path, query_update=cls._API_QUERY)
+
+    @staticmethod
+    def _get_episode_url(episode, episode_id):
+        return 'https://nebula.tv/videos/{0}'.format(episode_id)
+
+    @classmethod
+    def url_result(cls, url, *args, **kwargs):
+        url_transparent = kwargs.pop('url_transparent', False)
+        smuggled_data = kwargs.pop('smuggled_data', None)
+        if smuggled_data:
+            url = smuggle_url(url, smuggled_data)
+        ie_key = args[0] if len(args) > 0 else kwargs.get('ie_key')
+        if not ie_key:
+            args = (NebulaIE.ie_key(),) + args
+        return merge_dicts(
+            {'_type': 'url_transparent'} if url_transparent else {},
+            super(NebulaPlaylistBaseIE, cls).url_result(url, *args),
+            **kwargs)
+
+    def _generate_playlist_entries(self, pl_id=None, slug=None, dl_note=None):
+        next_url = self._get_api_url(pl_id)
+        if dl_note is None:
+            dl_note = self.IE_NAME.rpartition(':')[::2]
+            if dl_note[0] and dl_note[1]:
+                dl_note = '{0} '.format(dl_note[1])
+            else:
+                dl_note = ''
+        slug = slug or pl_id
+        for page_num in itertools.count(1):
+            episodes = self._call_api(
+                next_url, slug, note='Retrieving {0}page {1}'.format(
+                    dl_note, page_num))
+            for episode in traverse_obj(episodes, ('results', Ellipsis)):
+                metadata = self._extract_video_metadata(episode)
+                yield self.url_result(
+                    self._get_episode_url(episode, metadata['display_id']),
+                    smuggled_data={'id': episode['id']}, url_transparent=True,
+                    **metadata)
+            next_url = episodes.get('next')
+            if not next_url:
+                break
+
+
+class NebulaSubscriptionsIE(NebulaPlaylistBaseIE):
+    IE_NAME = 'nebula:subscriptions'
+    _VALID_URL = r'{0}/myshows'.format(_BASE_URL_RE)
+    _API_QUERY = {
+        'following': 'true',
+        'include': 'engagement',
+        'ordering': '-published_at',
+    }
+    _TESTS = [{
+        'url': 'https://nebula.tv/myshows',
+        'playlist_mincount': 1,
+        'info_dict': {
+            'id': 'myshows',
+        },
+        'skip': 'You must be logged in to find your subscriptions',
+    }]
+
+    def _call_api(self, *args, **kwargs):
+
+        try:
+            return super(NebulaSubscriptionsIE, self)._call_api(*args, **kwargs)
+        except ExtractorError as e:
+            if isinstance(e.cause, HTTPError) and e.cause.status == 400:
+                self.raise_login_required('You must be logged in to find your subscriptions')
+            raise
+
+    def _real_extract(self, url):
+        slug = url_basename(url)
+        return self.playlist_result(self._generate_playlist_entries(slug), slug)
+
+
+class NebulaChannelIE(NebulaPlaylistBaseIE):
+    IE_NAME = 'nebula:channel'
+    _VALID_URL = r'{0}/(?!myshows|library|videos)(?P<id>[\w-]+)/?(?:$|[?#])'.format(_BASE_URL_RE)
+    _TESTS = [{
+        'url': 'https://nebula.tv/tom-scott-presents-money',
+        'info_dict': {
+            'id': 'tom-scott-presents-money',
+            'title': 'Tom Scott Presents: Money',
+            'description': 'Tom Scott hosts a series all about trust, negotiation and money.',
+        },
+        'playlist_count': 5,
+    }, {
+        'url': 'https://nebula.tv/lindsayellis',
+        'info_dict': {
+            'id': 'lindsayellis',
+            'title': 'Lindsay Ellis',
+            'description': 'Enjoy these hottest of takes on Disney, Transformers, and Musicals.',
+        },
+        'playlist_mincount': 2,
+    }, {
+        'url': 'https://nebula.tv/johnnyharris',
+        'info_dict': {
+            'id': 'johnnyharris',
+            'title': 'Johnny Harris',
+            'description': 'I make videos about maps and many other things.',
+        },
+        'playlist_mincount': 90,
+    }, {
+        'url': 'https://nebula.tv/copyright-for-fun-and-profit',
+        'info_dict': {
+            'id': 'copyright-for-fun-and-profit',
+            'title': 'Copyright for Fun and Profit',
+            'description': 'md5:6690248223eed044a9f11cd5a24f9742',
+        },
+        'playlist_count': 23,
+    }, {
+        'url': 'https://nebula.tv/trussissuespodcast',
+        'info_dict': {
+            'id': 'trussissuespodcast',
+            'title': 'Bite the Ballot',
+            'description': 'md5:a08c4483bc0b705881d3e0199e721385',
+        },
+        'playlist_mincount': 80,
+    }]
+
+    @classmethod
+    def _get_api_url(cls, item_id, path='/video_channels/{0}/video_episodes/'):
+        return super(NebulaChannelIE, cls)._get_api_url(
+            item_id, path=path.format(item_id))
+
+    @classmethod
+    def _get_episode_url(cls, episode, episode_id):
+        return (
+            episode.get('share_url')
+            or super(NebulaChannelIE, cls)._get_episode_url(episode, episode_id))
+
+    def _generate_class_entries(self, channel):
+        for lesson in traverse_obj(channel, ('lessons', Ellipsis)):
+            metadata = self._extract_video_metadata(lesson)
+            yield self.url_result(
+                lesson.get('share_url') or 'https://nebula.tv/{0}/{1}'.format(
+                    metadata['class_slug'], metadata['slug']),
+                smuggled_data={'id': lesson['id']}, url_transparent=True,
+                **metadata)
+
+    def _generate_podcast_entries(self, collection_id, collection_slug):
+        next_url = 'https://content.api.nebula.app/podcast_channels/{0}/podcast_episodes/?ordering=-published_at&premium=true'.format(
+            collection_id)
+        for page_num in itertools.count(1):
+            episodes = self._call_api(next_url, collection_slug, note='Retrieving podcast page {0}'.format(page_num))
+
+            for episode in traverse_obj(episodes, ('results', lambda _, v: url_or_none(v['share_url']))):
+                yield self.url_result(episode['share_url'], NebulaClassIE)
+            next_url = episodes.get('next')
+            if not next_url:
+                break
+
+    def _real_extract(self, url):
+        collection_slug = self._match_id(url)
+        channel = self._call_api(
+            'https://content.api.nebula.app/content/{0}/?include=lessons'.format(
+                collection_slug),
+            collection_slug, note='Retrieving channel')
+
+        channel_type = traverse_obj(channel, 'type')
+        if channel_type == 'class':
+            entries = self._generate_class_entries(channel)
+        elif channel_type == 'podcast_channel':
+            entries = self._generate_podcast_entries(channel['id'], collection_slug)
+        else:
+            entries = self._generate_playlist_entries(channel['id'], collection_slug)
+
+        return self.playlist_result(
+            entries,
+            playlist_id=collection_slug,
+            playlist_title=channel.get('title'),
+            playlist_description=channel.get('description'))
--- a/youtube_dl/extractor/youtube.py
+++ b/youtube_dl/extractor/youtube.py
@ -27,6 +27,7 @@ from ..compat import (
 )
 from ..jsinterp import JSInterpreter
 from ..utils import (
+    bug_reports_message,
    clean_html,
    dict_get,
    error_to_compat_str,
@ -65,6 +66,7 @@ from ..utils import (
    url_or_none,
    urlencode_postdata,
    urljoin,
+    variadic,
 )


@ -120,7 +122,8 @@ class YoutubeBaseInfoExtractor(InfoExtractor):
            'INNERTUBE_CONTEXT': {
                'client': {
                    'clientName': 'TVHTML5',
-                    'clientVersion': '7.20241201.18.00',
+                    'clientVersion': '7.20250120.19.00',
+                    'userAgent': 'Mozilla/5.0 (ChromiumStylePlatform) Cobalt/Version',
                },
            },
            'INNERTUBE_CONTEXT_CLIENT_NAME': 7,
@ -460,6 +463,26 @@ class YoutubeBaseInfoExtractor(InfoExtractor):
            'uploader': uploader,
        }

+    @staticmethod
+    def _extract_thumbnails(data, *path_list, **kw_final_key):
+        """
+        Extract thumbnails from thumbnails dict
+        @param path_list: path list to level that contains 'thumbnails' key
+        """
+        final_key = kw_final_key.get('final_key', 'thumbnails')
+
+        return traverse_obj(data, ((
+            tuple(variadic(path) + (final_key, Ellipsis)
+                  for path in path_list or [()])), {
+            'url': ('url', T(url_or_none),
+                    # Sometimes youtube gives a wrong thumbnail URL. See:
+                    # https://github.com/yt-dlp/yt-dlp/issues/233
+                    # https://github.com/ytdl-org/youtube-dl/issues/28023
+                    T(lambda u: update_url(u, query=None) if u and 'maxresdefault' in u else u)),
+            'height': ('height', T(int_or_none)),
+            'width': ('width', T(int_or_none)),
+        }, T(lambda t: t if t.get('url') else None)))
+
    def _search_results(self, query, params):
        data = {
            'context': {
@ -1829,12 +1852,22 @@ class YoutubeIE(YoutubeBaseInfoExtractor):

        if func_code:
            return jsi, player_id, func_code
+        return self._extract_n_function_code_jsi(video_id, jsi, player_id)

-        func_name = self._extract_n_function_name(jscode)
+    def _extract_n_function_code_jsi(self, video_id, jsi, player_id=None):
+
+        var_ay = self._search_regex(
+            r'(?:[;\s]|^)\s*(var\s*[\w$]+\s*=\s*"[^"]+"\s*\.\s*split\("\{"\))(?=\s*[,;])',
+            jsi.code, 'useful values', default='')
+
+        func_name = self._extract_n_function_name(jsi.code)

        func_code = jsi.extract_function_code(func_name)
+        if var_ay:
+            func_code = (func_code[0], ';\n'.join((var_ay, func_code[1])))

-        self.cache.store('youtube-nsig', player_id, func_code)
+        if player_id:
+            self.cache.store('youtube-nsig', player_id, func_code)
        return jsi, player_id, func_code

    def _extract_n_function_from_code(self, jsi, func_code):
@ -3183,8 +3216,12 @@ class YoutubeTabIE(YoutubeBaseInfoExtractor):
            expected_type=txt_or_none)

    def _grid_entries(self, grid_renderer):
-        for item in grid_renderer['items']:
-            if not isinstance(item, dict):
+        for item in traverse_obj(grid_renderer, ('items', Ellipsis, T(dict))):
+            lockup_view_model = traverse_obj(item, ('lockupViewModel', T(dict)))
+            if lockup_view_model:
+                entry = self._extract_lockup_view_model(lockup_view_model)
+                if entry:
+                    yield entry
                continue
            renderer = self._extract_grid_item_renderer(item)
            if not isinstance(renderer, dict):
@ -3268,6 +3305,25 @@ class YoutubeTabIE(YoutubeBaseInfoExtractor):
                continue
            yield self._extract_video(renderer)

+    def _extract_lockup_view_model(self, view_model):
+        content_id = view_model.get('contentId')
+        if not content_id:
+            return
+        content_type = view_model.get('contentType')
+        if content_type not in ('LOCKUP_CONTENT_TYPE_PLAYLIST', 'LOCKUP_CONTENT_TYPE_PODCAST'):
+            self.report_warning(
+                'Unsupported lockup view model content type "{0}"{1}'.format(content_type, bug_reports_message()), only_once=True)
+            return
+        return merge_dicts(self.url_result(
+            update_url_query('https://www.youtube.com/playlist', {'list': content_id}),
+            ie=YoutubeTabIE.ie_key(), video_id=content_id), {
+                'title': traverse_obj(view_model, (
+                    'metadata', 'lockupMetadataViewModel', 'title', 'content', T(compat_str))),
+                'thumbnails': self._extract_thumbnails(view_model, (
+                    'contentImage', 'collectionThumbnailViewModel', 'primaryThumbnail',
+                    'thumbnailViewModel', 'image'), final_key='sources'),
+        })
+
    def _video_entry(self, video_renderer):
        video_id = video_renderer.get('videoId')
        if video_id:
--- a/youtube_dl/jsinterp.py
+++ b/youtube_dl/jsinterp.py
@ -1,10 +1,12 @@
 # coding: utf-8
 from __future__ import unicode_literals

+import calendar
 import itertools
 import json
 import operator
 import re
+import time

 from functools import update_wrapper, wraps

@ -12,8 +14,10 @@ from .utils import (
    error_to_compat_str,
    ExtractorError,
    float_or_none,
+    int_or_none,
    js_to_json,
    remove_quotes,
+    str_or_none,
    unified_timestamp,
    variadic,
    write_string,
@ -150,6 +154,7 @@ def _js_to_primitive(v):
    )


+# more exact: yt-dlp/yt-dlp#12110
 def _js_toString(v):
    return (
        'undefined' if v is JS_Undefined
@ -158,7 +163,7 @@ def _js_toString(v):
        else 'null' if v is None
        # bool <= int: do this first
        else ('false', 'true')[v] if isinstance(v, bool)
-        else '{0:.7f}'.format(v).rstrip('.0') if isinstance(v, compat_numeric_types)
+        else re.sub(r'(?<=\d)\.?0*$', '', '{0:.7f}'.format(v)) if isinstance(v, compat_numeric_types)
        else _js_to_primitive(v))


@ -404,6 +409,7 @@ class JSInterpreter(object):
    class Exception(ExtractorError):
        def __init__(self, msg, *args, **kwargs):
            expr = kwargs.pop('expr', None)
+            msg = str_or_none(msg, default='"None"')
            if expr is not None:
                msg = '{0} in: {1!r:.100}'.format(msg.rstrip(), expr)
            super(JSInterpreter.Exception, self).__init__(msg, *args, **kwargs)
@ -431,6 +437,7 @@ class JSInterpreter(object):
                flags, _ = self.regex_flags(flags)
            # First, avoid https://github.com/python/cpython/issues/74534
            self.__self = None
+            pattern_txt = str_or_none(pattern_txt) or '(?:)'
            self.__pattern_txt = pattern_txt.replace('[[', r'[\[')
            self.__flags = flags

@ -475,6 +482,73 @@ class JSInterpreter(object):
                flags |= cls.RE_FLAGS[ch]
            return flags, expr[idx + 1:]

+    class JS_Date(object):
+        _t = None
+
+        @staticmethod
+        def __ymd_etc(*args, **kw_is_utc):
+            # args: year, monthIndex, day, hours, minutes, seconds, milliseconds
+            is_utc = kw_is_utc.get('is_utc', False)
+
+            args = list(args[:7])
+            args += [0] * (9 - len(args))
+            args[1] += 1  # month 0..11 -> 1..12
+            ms = args[6]
+            for i in range(6, 9):
+                args[i] = -1  # don't know
+            if is_utc:
+                args[-1] = 1
+            # TODO: [MDN] When a segment overflows or underflows its expected
+            # range, it usually "carries over to" or "borrows from" the higher segment.
+            try:
+                mktime = calendar.timegm if is_utc else time.mktime
+                return mktime(time.struct_time(args)) * 1000 + ms
+            except (OverflowError, ValueError):
+                return None
+
+        @classmethod
+        def UTC(cls, *args):
+            t = cls.__ymd_etc(*args, is_utc=True)
+            return _NaN if t is None else t
+
+        @staticmethod
+        def parse(date_str, **kw_is_raw):
+            is_raw = kw_is_raw.get('is_raw', False)
+
+            t = unified_timestamp(str_or_none(date_str), False)
+            return int(t * 1000) if t is not None else t if is_raw else _NaN
+
+        @staticmethod
+        def now(**kw_is_raw):
+            is_raw = kw_is_raw.get('is_raw', False)
+
+            t = time.time()
+            return int(t * 1000) if t is not None else t if is_raw else _NaN
+
+        def __init__(self, *args):
+            if not args:
+                args = [self.now(is_raw=True)]
+            if len(args) == 1:
+                if isinstance(args[0], JSInterpreter.JS_Date):
+                    self._t = int_or_none(args[0].valueOf(), default=None)
+                else:
+                    arg_type = _js_typeof(args[0])
+                    if arg_type == 'string':
+                        self._t = self.parse(args[0], is_raw=True)
+                    elif arg_type == 'number':
+                        self._t = int(args[0])
+            else:
+                self._t = self.__ymd_etc(*args)
+
+        def toString(self):
+            try:
+                return time.strftime('%a %b %0d %Y %H:%M:%S %Z%z', self._t).rstrip()
+            except TypeError:
+                return "Invalid Date"
+
+        def valueOf(self):
+            return _NaN if self._t is None else self._t
+
    @classmethod
    def __op_chars(cls):
        op_chars = set(';,[')
@ -599,14 +673,15 @@ class JSInterpreter(object):
        except Exception as e:
            raise self.Exception('Failed to evaluate {left_val!r:.50} {op} {right_val!r:.50}'.format(**locals()), expr, cause=e)

-    def _index(self, obj, idx, allow_undefined=True):
+    def _index(self, obj, idx, allow_undefined=None):
        if idx == 'length' and isinstance(obj, list):
            return len(obj)
        try:
            return obj[int(idx)] if isinstance(obj, list) else obj[compat_str(idx)]
        except (TypeError, KeyError, IndexError) as e:
-            if allow_undefined:
-                # when is not allowed?
+            # allow_undefined is None gives correct behaviour
+            if allow_undefined or (
+                    allow_undefined is None and not isinstance(e, TypeError)):
                return JS_Undefined
            raise self.Exception('Cannot get index {idx!r:.100}'.format(**locals()), expr=repr(obj), cause=e)

@ -715,7 +790,7 @@ class JSInterpreter(object):

        new_kw, _, obj = expr.partition('new ')
        if not new_kw:
-            for klass, konstr in (('Date', lambda x: int(unified_timestamp(x, False) * 1000)),
+            for klass, konstr in (('Date', lambda *x: self.JS_Date(*x).valueOf()),
                                  ('RegExp', self.JS_RegExp),
                                  ('Error', self.Exception)):
                if not obj.startswith(klass + '('):
@ -1034,6 +1109,7 @@ class JSInterpreter(object):
                    'String': compat_str,
                    'Math': float,
                    'Array': list,
+                    'Date': self.JS_Date,
                }
                obj = local_vars.get(variable)
                if obj in (JS_Undefined, None):
@ -1086,6 +1162,8 @@ class JSInterpreter(object):
                        assertion(len(argvals) == 2, 'takes two arguments')
                        return argvals[0] ** argvals[1]
                    raise self.Exception('Unsupported Math method ' + member, expr=expr)
+                elif obj is self.JS_Date:
+                    return getattr(obj, member)(*argvals)

                if member == 'split':
                    assertion(len(argvals) <= 2, 'takes at most two arguments')
--- a/youtube_dl/utils.py
+++ b/youtube_dl/utils.py
@ -6715,3 +6715,46 @@ class _UnsafeExtensionError(Exception):
                raise cls(extension)

        return extension
+
+
+def json_stringify(json_expr, **kwargs):
+    # /, *, concise=True, result_encoding='utf-8', **{**encode_result_kwargs, **dumps_kwargs}
+    """
+    Convert json_expr to a string, suitable for passing over a network
+
+    @param  json_expr    Python representation of a JSON expression
+
+    KW-only parameters
+    @param  {bool}  concise      do not space around , and : (default True)
+    @param  {str}   result_encoding      encoding, if any, of the result
+                                         (default 'utf-8')
+    @param  {str}   errors      error handling for result_encoding
+    @param  ...                 other KW arguments [assed to json.dumps()
+    @returns  {bytes|str}       stringified JSON, encoded to bytes using
+                                result_encoding, or Unicode if none
+
+    With the default arguments, the return value is a byte string
+    suitable to be passed as POST data.
+
+    Inspired by JSON.stringify [1], but not so much as to emulate its optional
+    replacer (use cls=replacer_JSON_encoder) or space (use indent=space for space > 0).
+    1. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify
+    """
+
+    # extract all non-dumps_kwargs
+    concise = kwargs.pop('concise', True)
+    result_encoding = kwargs.pop('result_encoding', 'utf-8')
+    result_errors = kwargs.pop('errors', None)
+
+    if concise:
+        kwargs['separators'] = (',', ':')
+        kwargs = compat_kwargs(kwargs)
+    result = json.dumps(json_expr, **kwargs)
+
+    if result_encoding:
+        kwargs = compat_kwargs({'errors': result_errors}) if result_errors else {}
+        result = result.encode(result_encoding, **kwargs)
+        return result
+
+    # return a Unicode value of type type('')
+    return '' + result
Author	SHA1	Message	Date
Henrik Heimbuerger	3da9ce7a11	Merge d4664a53467eade879971de3950424299f68bd3a into 420d53387cff54ea1fccca061438d59bdb50a39c	2025-03-16 13:09:11 +00:00
dirkf	420d53387c	[JSInterp] Improve tests * from yt-dlp/yt-dlp#12313 * also fix d7c2708	2025-03-11 02:00:24 +00:00
dirkf	32f89de92b	[YouTube] Update TVHTML5 client parameters * resolves #33078	2025-03-11 02:00:24 +00:00
dirkf	283dca56fe	[YouTube] Initially support tce-style player JS * resolves #33079	2025-03-11 02:00:24 +00:00
dirkf	422b1b31cf	[YouTube] Temporarily redirect from tce-style player JS	2025-03-11 02:00:24 +00:00
dirkf	1dc27e1c3b	[JSInterp] Make indexing error handling more conformant * by default TypeError -> undefined, else raise * set allow_undefined=True/False to override	2025-03-11 02:00:24 +00:00
dirkf	af049e309b	[JSInterp] Handle undefined, etc, passed to JS_RegExp and Exception	2025-03-11 02:00:24 +00:00
dirkf	94849bc997	[JSInterp] Improve Date processing * add JS_Date class implementing JS Date * support constructor args other than date string * support static methods of Date * Date objects are still automatically coerced to timestamp before using in JS.	2025-03-11 02:00:24 +00:00
dirkf	974c7d7f34	[compat] Fix inheriting from compat_collections_chain_map * see ytdl-org/youtube-dl#33079#issuecomment-2704038049	2025-03-11 02:00:24 +00:00
dirkf	8738407d77	[compat] Support zstd Content-Encoding * see RFC 8878 7.2	2025-03-11 02:00:24 +00:00
dirkf	cecaa18b80	[compat] Clean-up * make workaround_optparse_bug9161 private * add comments * avoid leaving test objects behind	2025-03-11 02:00:24 +00:00
dirkf	673277e510	[YouTube] Fix 91b1569	2025-02-28 01:02:20 +00:00
dirkf	91b1569f68	[YouTube] Fix channel playlist extraction (#33074 ) * [YouTube] Extract playlist items from LOCKUP_VIEW_MODEL_... * resolves #33073 * thx seproDev (yt-dlp/yt-dlp#11615) Co-authored-by: sepro <sepro@sepr0.com>	2025-02-28 00:02:10 +00:00
dirkf	d4664a5346	Remove (last?) set literal	2024-11-23 11:14:30 +00:00
dirkf	92d881c33f	Linty	2024-11-23 11:03:37 +00:00
dirkf	bd4729a866	[utils] Add json_stringify() * somewhat like JSON.stringify() * replaces json.dumps(..., separators=(',',':')).encode('utf-8') * more kwarg options available	2024-11-23 11:00:00 +00:00
dirkf	79abdae734	Add Art19IE to extractors.py And clean up sorting	2024-11-23 10:47:21 +00:00
dirkf	88619125c8	Create art19.py	2024-11-23 10:39:54 +00:00
dirkf	3565d21951	Merge branch 'master' into add-nebula-support	2024-11-23 10:34:26 +00:00
dirkf	ddbadd037f	Update PR with back-port from its development in yt-dlp	2024-11-23 10:31:42 +00:00
Henrik Heimbuerger	a0f69f9526	[nebula] Fix stale session issues When Nebula isn't accessed for a while, the Zype access token stored on the Nebula backend expires. It is then no longer returned by the user endpoint. The Nebula frontend has the same issue and keeps polling for the Zype token in this case. This isn't implemented in this extractor yet, but at least a specific error message now prints some helpful advice.	2021-01-17 22:25:51 +01:00
Henrik Heimbuerger	9fdfd6d3ba	[nebula] Prevent cookies from breaking Nebula auth When the 'sessionid' cookie is submitted to the `/auth/login/` endpoint, the response is always a 403. This typically happens when youtube_dl is run with both `--netrc` and `--cookies` as your default configuration. In that situation, the first authentication succeeds and stores the `sessionid` cookie in the cookie jar. During subsequent authentication attempts, the cookie is sent alongside and causes the authentication to fail. This is very unexpected and we therefore specifically handle this case.	2021-01-17 15:52:02 +01:00
Henrik Heimbuerger	59c0e6e3d8	[nebula] Log attempted authentication method	2021-01-17 15:52:02 +01:00
Henrik Heimbuerger	8b4c9da62a	[nebula] Clean up credentials-based authentication	2021-01-17 15:52:02 +01:00
Henrik Heimbuerger	2562c9ec74	[nebula] Implement PoC of netrc authentication	2021-01-17 15:52:02 +01:00
Henrik Heimbuerger	f8eb89748b	[nebula] Update test video checksums	2021-01-17 15:52:02 +01:00
Henrik Heimbuerger	30362440dc	[nebula] Improve performance by avoiding redirect	2021-01-17 15:52:02 +01:00
Henrik Heimbuerger	1317a43a6a	[nebula] Implement Zype API key retrieval from JS chunk	2021-01-17 15:52:02 +01:00
Henrik Heimbuerger	18582060c2	[nebula] Rewrite extractor to new frontend (refs #21258 )	2021-01-17 15:52:02 +01:00
Henrik Heimbuerger	af3434b839	[nebula] Relax meta data lookups	2021-01-17 15:52:01 +01:00
Henrik Heimbuerger	61cead3235	[nebula] Add better channel title extraction (refs #21258 )	2021-01-17 15:52:01 +01:00
Henrik Heimbuerger	469cae38cd	[nebula] Add additional test cases and improve cookie envvar handling	2021-01-17 15:52:01 +01:00
Henrik Heimbuerger	f6ac8cd495	[nebula] Add basic support for Nebula (refs #21258 )	2021-01-17 15:52:01 +01:00