SickGear/lib/feedparser/mixin.py

# Copyright 2010-2023 Kurt McKee <contactme@kurtmckee.org>
# Copyright 2002-2008 Mark Pilgrim
# All rights reserved.
#
# This file is a part of feedparser.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice,
#   this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
#   this list of conditions and the following disclaimer in the documentation
#   and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.

import base64
import binascii
import copy
import html.entities
import re
import xml.sax.saxutils
from typing import Dict

from .html import _cp1252
from .namespaces import _base, cc, dc, georss, itunes, mediarss, psc
from .sanitizer import HTMLSanitizer, sanitize_html
from .urls import _urljoin, make_safe_absolute_uri, resolve_relative_uris
from .util import FeedParserDict

email_pattern = re.compile(
    r"(([a-zA-Z0-9_.+-]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)"
    r"|(([a-zA-Z0-9-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(]?))"
    r"(\?subject=\S+)?"
)


class XMLParserMixin(
    _base.Namespace,
    cc.Namespace,
    dc.Namespace,
    georss.Namespace,
    itunes.Namespace,
    mediarss.Namespace,
    psc.Namespace,
):
    namespaces = {
        "": "",
        "http://backend.userland.com/rss": "",
        "http://blogs.law.harvard.edu/tech/rss": "",
        "http://purl.org/rss/1.0/": "",
        "http://my.netscape.com/rdf/simple/0.9/": "",
        "http://example.com/newformat#": "",
        "http://example.com/necho": "",
        "http://purl.org/echo/": "",
        "uri/of/echo/namespace#": "",
        "http://purl.org/pie/": "",
        "http://purl.org/atom/ns#": "",
        "http://www.w3.org/2005/Atom": "",
        "http://purl.org/rss/1.0/modules/rss091#": "",
        "http://webns.net/mvcb/": "admin",
        "http://purl.org/rss/1.0/modules/aggregation/": "ag",
        "http://purl.org/rss/1.0/modules/annotate/": "annotate",
        "http://media.tangent.org/rss/1.0/": "audio",
        "http://backend.userland.com/blogChannelModule": "blogChannel",
        "http://creativecommons.org/ns#license": "cc",
        "http://web.resource.org/cc/": "cc",
        "http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html": (
            "creativeCommons"
        ),
        "http://backend.userland.com/creativeCommonsRssModule": "creativeCommons",
        "http://purl.org/rss/1.0/modules/company": "co",
        "http://purl.org/rss/1.0/modules/content/": "content",
        "http://my.theinfo.org/changed/1.0/rss/": "cp",
        "http://purl.org/dc/elements/1.1/": "dc",
        "http://purl.org/dc/terms/": "dcterms",
        "http://purl.org/rss/1.0/modules/email/": "email",
        "http://purl.org/rss/1.0/modules/event/": "ev",
        "http://rssnamespace.org/feedburner/ext/1.0": "feedburner",
        "http://freshmeat.net/rss/fm/": "fm",
        "http://xmlns.com/foaf/0.1/": "foaf",
        "http://www.w3.org/2003/01/geo/wgs84_pos#": "geo",
        "http://www.georss.org/georss": "georss",
        "http://www.opengis.net/gml": "gml",
        "http://postneo.com/icbm/": "icbm",
        "http://purl.org/rss/1.0/modules/image/": "image",
        "http://www.itunes.com/DTDs/PodCast-1.0.dtd": "itunes",
        "http://example.com/DTDs/PodCast-1.0.dtd": "itunes",
        "http://purl.org/rss/1.0/modules/link/": "l",
        "http://search.yahoo.com/mrss": "media",
        # Version 1.1.2 of the Media RSS spec added the trailing slash on the namespace
        "http://search.yahoo.com/mrss/": "media",
        "http://madskills.com/public/xml/rss/module/pingback/": "pingback",
        "http://prismstandard.org/namespaces/1.2/basic/": "prism",
        "http://www.w3.org/1999/02/22-rdf-syntax-ns#": "rdf",
        "http://www.w3.org/2000/01/rdf-schema#": "rdfs",
        "http://purl.org/rss/1.0/modules/reference/": "ref",
        "http://purl.org/rss/1.0/modules/richequiv/": "reqv",
        "http://purl.org/rss/1.0/modules/search/": "search",
        "http://purl.org/rss/1.0/modules/slash/": "slash",
        "http://schemas.xmlsoap.org/soap/envelope/": "soap",
        "http://purl.org/rss/1.0/modules/servicestatus/": "ss",
        "http://hacks.benhammersley.com/rss/streaming/": "str",
        "http://purl.org/rss/1.0/modules/subscription/": "sub",
        "http://purl.org/rss/1.0/modules/syndication/": "sy",
        "http://schemas.pocketsoap.com/rss/myDescModule/": "szf",
        "http://purl.org/rss/1.0/modules/taxonomy/": "taxo",
        "http://purl.org/rss/1.0/modules/threading/": "thr",
        "http://purl.org/rss/1.0/modules/textinput/": "ti",
        "http://madskills.com/public/xml/rss/module/trackback/": "trackback",
        "http://wellformedweb.org/commentAPI/": "wfw",
        "http://purl.org/rss/1.0/modules/wiki/": "wiki",
        "http://www.w3.org/1999/xhtml": "xhtml",
        "http://www.w3.org/1999/xlink": "xlink",
        "http://www.w3.org/XML/1998/namespace": "xml",
        "http://podlove.org/simple-chapters": "psc",
    }
    _matchnamespaces: Dict[str, str] = {}

    can_be_relative_uri = {
        "comments",
        "docs",
        "href",
        "icon",
        "id",
        "link",
        "logo",
        "url",
        "wfw_comment",
        "wfw_commentrss",
    }

    can_contain_relative_uris = {
        "content",
        "copyright",
        "description",
        "info",
        "rights",
        "subtitle",
        "summary",
        "tagline",
        "title",
    }

    can_contain_dangerous_markup = {
        "content",
        "copyright",
        "description",
        "info",
        "rights",
        "subtitle",
        "summary",
        "tagline",
        "title",
    }

    html_types = {
        "application/xhtml+xml",
        "text/html",
    }

    def __init__(self):
        if not self._matchnamespaces:
            for k, v in self.namespaces.items():
                self._matchnamespaces[k.lower()] = v
        self.feeddata = FeedParserDict()  # feed-level data
        self.entries = []  # list of entry-level data
        self.version = ""  # feed type/version, see SUPPORTED_VERSIONS
        self.namespaces_in_use = {}  # dictionary of namespaces defined by the feed
        self.resolve_relative_uris = False
        self.sanitize_html = False

        # the following are used internally to track state;
        # this is really out of control and should be refactored
        self.infeed = 0
        self.inentry = 0
        self.incontent = 0
        self.intextinput = 0
        self.inimage = 0
        self.inauthor = 0
        self.incontributor = 0
        self.inpublisher = 0
        self.insource = 0

        self.sourcedata = FeedParserDict()
        self.contentparams = FeedParserDict()
        self._summaryKey = None
        self.namespacemap = {}
        self.elementstack = []
        self.basestack = []
        self.langstack = []
        self.svgOK = 0
        self.title_depth = -1
        self.depth = 0
        self.hasContent = 0
        if self.lang:
            self.feeddata["language"] = self.lang.replace("_", "-")

        # A map of the following form:
        #     {
        #         object_that_value_is_set_on: {
        #             property_name: depth_of_node_property_was_extracted_from,
        #             other_property: depth_of_node_property_was_extracted_from,
        #         },
        #     }
        self.property_depth_map = {}
        super().__init__()

    def _normalize_attributes(self, kv):
        raise NotImplementedError

    def unknown_starttag(self, tag, attrs):
        # increment depth counter
        self.depth += 1

        # normalize attrs
        attrs = [self._normalize_attributes(attr) for attr in attrs]

        # track xml:base and xml:lang
        attrs_d = dict(attrs)
        baseuri = attrs_d.get("xml:base", attrs_d.get("base")) or self.baseuri
        if isinstance(baseuri, bytes):
            baseuri = baseuri.decode(self.encoding, "ignore")
        # ensure that self.baseuri is always an absolute URI that
        # uses a whitelisted URI scheme (e.g. not `javscript:`)
        if self.baseuri:
            self.baseuri = make_safe_absolute_uri(self.baseuri, baseuri) or self.baseuri
        else:
            self.baseuri = _urljoin(self.baseuri, baseuri)
        lang = attrs_d.get("xml:lang", attrs_d.get("lang"))
        if lang == "":
            # xml:lang could be explicitly set to '', we need to capture that
            lang = None
        elif lang is None:
            # if no xml:lang is specified, use parent lang
            lang = self.lang
        if lang:
            if tag in ("feed", "rss", "rdf:RDF"):
                self.feeddata["language"] = lang.replace("_", "-")
        self.lang = lang
        self.basestack.append(self.baseuri)
        self.langstack.append(lang)

        # track namespaces
        for prefix, uri in attrs:
            if prefix.startswith("xmlns:"):
                self.track_namespace(prefix[6:], uri)
            elif prefix == "xmlns":
                self.track_namespace(None, uri)

        # track inline content
        if self.incontent and not self.contentparams.get("type", "xml").endswith("xml"):
            if tag in ("xhtml:div", "div"):
                return  # typepad does this 10/2007
            # element declared itself as escaped markup, but it isn't really
            self.contentparams["type"] = "application/xhtml+xml"
        if self.incontent and self.contentparams.get("type") == "application/xhtml+xml":
            if tag.find(":") != -1:
                prefix, tag = tag.split(":", 1)
                namespace = self.namespaces_in_use.get(prefix, "")
                if tag == "math" and namespace == "http://www.w3.org/1998/Math/MathML":
                    attrs.append(("xmlns", namespace))
                if tag == "svg" and namespace == "http://www.w3.org/2000/svg":
                    attrs.append(("xmlns", namespace))
            if tag == "svg":
                self.svgOK += 1
            return self.handle_data(f"<{tag}{self.strattrs(attrs)}>", escape=0)

        # match namespaces
        if tag.find(":") != -1:
            prefix, suffix = tag.split(":", 1)
        else:
            prefix, suffix = "", tag
        prefix = self.namespacemap.get(prefix, prefix)
        if prefix:
            prefix = prefix + "_"

        # Special hack for better tracking of empty textinput/image elements in
        # illformed feeds.
        if (not prefix) and tag not in ("title", "link", "description", "name"):
            self.intextinput = 0
        if (not prefix) and tag not in (
            "title",
            "link",
            "description",
            "url",
            "href",
            "width",
            "height",
        ):
            self.inimage = 0

        # call special handler (if defined) or default handler
        methodname = "_start_" + prefix + suffix
        try:
            method = getattr(self, methodname)
            return method(attrs_d)
        except AttributeError:
            # Since there's no handler or something has gone wrong we
            # explicitly add the element and its attributes.
            unknown_tag = prefix + suffix
            if len(attrs_d) == 0:
                # No attributes so merge it into the enclosing dictionary
                return self.push(unknown_tag, 1)
            else:
                # Has attributes so create it in its own dictionary
                context = self._get_context()
                context[unknown_tag] = attrs_d

    def unknown_endtag(self, tag):
        # match namespaces
        if tag.find(":") != -1:
            prefix, suffix = tag.split(":", 1)
        else:
            prefix, suffix = "", tag
        prefix = self.namespacemap.get(prefix, prefix)
        if prefix:
            prefix = prefix + "_"
        if suffix == "svg" and self.svgOK:
            self.svgOK -= 1

        # call special handler (if defined) or default handler
        methodname = "_end_" + prefix + suffix
        try:
            if self.svgOK:
                raise AttributeError()
            method = getattr(self, methodname)
            method()
        except AttributeError:
            self.pop(prefix + suffix)

        # track inline content
        if self.incontent and not self.contentparams.get("type", "xml").endswith("xml"):
            # element declared itself as escaped markup, but it isn't really
            if tag in ("xhtml:div", "div"):
                return  # typepad does this 10/2007
            self.contentparams["type"] = "application/xhtml+xml"
        if self.incontent and self.contentparams.get("type") == "application/xhtml+xml":
            tag = tag.split(":")[-1]
            self.handle_data("</%s>" % tag, escape=0)

        # track xml:base and xml:lang going out of scope
        if self.basestack:
            self.basestack.pop()
            if self.basestack and self.basestack[-1]:
                self.baseuri = self.basestack[-1]
        if self.langstack:
            self.langstack.pop()
            if self.langstack:  # and (self.langstack[-1] is not None):
                self.lang = self.langstack[-1]

        self.depth -= 1

    def handle_charref(self, ref):
        # Called for each character reference, e.g. for '&#160;', ref is '160'
        if not self.elementstack:
            return
        ref = ref.lower()
        if ref in ("34", "38", "39", "60", "62", "x22", "x26", "x27", "x3c", "x3e"):
            text = "&#%s;" % ref
        else:
            if ref[0] == "x":
                c = int(ref[1:], 16)
            else:
                c = int(ref)
            text = chr(c).encode("utf-8")
        self.elementstack[-1][2].append(text)

    def handle_entityref(self, ref):
        # Called for each entity reference, e.g. for '&copy;', ref is 'copy'
        if not self.elementstack:
            return
        if ref in ("lt", "gt", "quot", "amp", "apos"):
            text = "&%s;" % ref
        elif ref in self.entities:
            text = self.entities[ref]
            if text.startswith("&#") and text.endswith(";"):
                return self.handle_entityref(text)
        else:
            try:
                html.entities.name2codepoint[ref]
            except KeyError:
                text = "&%s;" % ref
            else:
                text = chr(html.entities.name2codepoint[ref]).encode("utf-8")
        self.elementstack[-1][2].append(text)

    def handle_data(self, text, escape=1):
        # Called for each block of plain text, i.e. outside of any tag and
        # not containing any character or entity references
        if not self.elementstack:
            return
        if escape and self.contentparams.get("type") == "application/xhtml+xml":
            text = xml.sax.saxutils.escape(text)
        self.elementstack[-1][2].append(text)

    def handle_comment(self, text):
        # Called for each comment, e.g. <!-- insert message here -->
        pass

    def handle_pi(self, text):
        # Called for each processing instruction, e.g. <?instruction>
        pass

    def handle_decl(self, text):
        pass

    def parse_declaration(self, i):
        # Override internal declaration handler to handle CDATA blocks.
        if self.rawdata[i : i + 9] == "<![CDATA[":
            k = self.rawdata.find("]]>", i)
            if k == -1:
                # CDATA block began but didn't finish
                k = len(self.rawdata)
                return k
            self.handle_data(xml.sax.saxutils.escape(self.rawdata[i + 9 : k]), 0)
            return k + 3
        else:
            k = self.rawdata.find(">", i)
            if k >= 0:
                return k + 1
            else:
                # We have an incomplete CDATA block.
                return k

    @staticmethod
    def map_content_type(content_type):
        content_type = content_type.lower()
        if content_type == "text" or content_type == "plain":
            content_type = "text/plain"
        elif content_type == "html":
            content_type = "text/html"
        elif content_type == "xhtml":
            content_type = "application/xhtml+xml"
        return content_type

    def track_namespace(self, prefix, uri):
        loweruri = uri.lower()
        if not self.version:
            if (prefix, loweruri) == (None, "http://my.netscape.com/rdf/simple/0.9/"):
                self.version = "rss090"
            elif loweruri == "http://purl.org/rss/1.0/":
                self.version = "rss10"
            elif loweruri == "http://www.w3.org/2005/atom":
                self.version = "atom10"
        if loweruri.find("backend.userland.com/rss") != -1:
            # match any backend.userland.com namespace
            uri = "http://backend.userland.com/rss"
            loweruri = uri
        if loweruri in self._matchnamespaces:
            self.namespacemap[prefix] = self._matchnamespaces[loweruri]
            self.namespaces_in_use[self._matchnamespaces[loweruri]] = uri
        else:
            self.namespaces_in_use[prefix or ""] = uri

    def resolve_uri(self, uri):
        return _urljoin(self.baseuri or "", uri)

    @staticmethod
    def decode_entities(element, data):
        return data

    @staticmethod
    def strattrs(attrs):
        return "".join(
            ' {}="{}"'.format(t[0], xml.sax.saxutils.escape(t[1], {'"': "&quot;"}))
            for t in attrs
        )

    def push(self, element, expecting_text):
        self.elementstack.append([element, expecting_text, []])

    def pop(self, element, strip_whitespace=1):
        if not self.elementstack:
            return
        if self.elementstack[-1][0] != element:
            return

        element, expecting_text, pieces = self.elementstack.pop()

        # Ensure each piece is a str for Python 3
        for i, v in enumerate(pieces):
            if isinstance(v, bytes):
                pieces[i] = v.decode("utf-8")

        if (
            self.version == "atom10"
            and self.contentparams.get("type", "text") == "application/xhtml+xml"
        ):
            # remove enclosing child element, but only if it is a <div> and
            # only if all the remaining content is nested underneath it.
            # This means that the divs would be retained in the following:
            #    <div>foo</div><div>bar</div>
            while pieces and len(pieces) > 1 and not pieces[-1].strip():
                del pieces[-1]
            while pieces and len(pieces) > 1 and not pieces[0].strip():
                del pieces[0]
            if (
                pieces
                and (pieces[0] == "<div>" or pieces[0].startswith("<div "))
                and pieces[-1] == "</div>"
            ):
                depth = 0
                for piece in pieces[:-1]:
                    if piece.startswith("</"):
                        depth -= 1
                        if depth == 0:
                            break
                    elif piece.startswith("<") and not piece.endswith("/>"):
                        depth += 1
                else:
                    pieces = pieces[1:-1]

        output = "".join(pieces)
        if strip_whitespace:
            output = output.strip()
        if not expecting_text:
            return output

        # decode base64 content
        if base64 and self.contentparams.get("base64", 0):
            try:
                output = base64.decodebytes(output.encode("utf8")).decode("utf8")
            except (binascii.Error, binascii.Incomplete, UnicodeDecodeError):
                pass

        # resolve relative URIs
        if (element in self.can_be_relative_uri) and output:
            # do not resolve guid elements with isPermalink="false"
            if not element == "id" or self.guidislink:
                output = self.resolve_uri(output)

        # decode entities within embedded markup
        if not self.contentparams.get("base64", 0):
            output = self.decode_entities(element, output)

        # some feed formats require consumers to guess
        # whether the content is html or plain text
        if (
            not self.version.startswith("atom")
            and self.contentparams.get("type") == "text/plain"
        ):
            if self.looks_like_html(output):
                self.contentparams["type"] = "text/html"

        # remove temporary cruft from contentparams
        try:
            del self.contentparams["mode"]
        except KeyError:
            pass
        try:
            del self.contentparams["base64"]
        except KeyError:
            pass

        is_htmlish = (
            self.map_content_type(self.contentparams.get("type", "text/html"))
            in self.html_types
        )
        # resolve relative URIs within embedded markup
        if is_htmlish and self.resolve_relative_uris:
            if element in self.can_contain_relative_uris:
                output = resolve_relative_uris(
                    output,
                    self.baseuri,
                    self.encoding,
                    self.contentparams.get("type", "text/html"),
                )

        # sanitize embedded markup
        if is_htmlish and self.sanitize_html:
            if element in self.can_contain_dangerous_markup:
                output = sanitize_html(
                    output, self.encoding, self.contentparams.get("type", "text/html")
                )

        if self.encoding and isinstance(output, bytes):
            output = output.decode(self.encoding, "ignore")

        # address common error where people take data that is already
        # utf-8, presume that it is iso-8859-1, and re-encode it.
        if self.encoding in ("utf-8", "utf-8_INVALID_PYTHON_3") and not isinstance(
            output, bytes
        ):
            try:
                output = output.encode("iso-8859-1").decode("utf-8")
            except (UnicodeEncodeError, UnicodeDecodeError):
                pass

        # map win-1252 extensions to the proper code points
        if not isinstance(output, bytes):
            output = output.translate(_cp1252)

        # categories/tags/keywords/whatever are handled in _end_category or
        # _end_tags or _end_itunes_keywords
        if element in ("category", "tags", "itunes_keywords"):
            return output

        if element == "title" and -1 < self.title_depth <= self.depth:
            return output

        # store output in appropriate place(s)
        if self.inentry and not self.insource:
            if element == "content":
                self.entries[-1].setdefault(element, [])
                contentparams = copy.deepcopy(self.contentparams)
                contentparams["value"] = output
                self.entries[-1][element].append(contentparams)
            elif element == "link":
                if not self.inimage:
                    # query variables in urls in link elements are improperly
                    # converted from `?a=1&b=2` to `?a=1&b;=2` as if they're
                    # unhandled character references. fix this special case.
                    output = output.replace("&amp;", "&")
                    output = re.sub("&([A-Za-z0-9_]+);", r"&\g<1>", output)
                    self.entries[-1][element] = output
                    if output:
                        self.entries[-1]["links"][-1]["href"] = output
            else:
                if element == "description":
                    element = "summary"
                old_value_depth = self.property_depth_map.setdefault(
                    self.entries[-1], {}
                ).get(element)
                if old_value_depth is None or self.depth <= old_value_depth:
                    self.property_depth_map[self.entries[-1]][element] = self.depth
                    self.entries[-1][element] = output
                if self.incontent:
                    contentparams = copy.deepcopy(self.contentparams)
                    contentparams["value"] = output
                    self.entries[-1][element + "_detail"] = contentparams
        elif (
            self.infeed or self.insource
        ):  # and (not self.intextinput) and (not self.inimage):
            context = self._get_context()
            if element == "description":
                element = "subtitle"
            context[element] = output
            if element == "link":
                # fix query variables; see above for the explanation
                output = re.sub("&([A-Za-z0-9_]+);", r"&\g<1>", output)
                context[element] = output
                context["links"][-1]["href"] = output
            elif self.incontent:
                contentparams = copy.deepcopy(self.contentparams)
                contentparams["value"] = output
                context[element + "_detail"] = contentparams
        return output

    def push_content(self, tag, attrs_d, default_content_type, expecting_text):
        self.incontent += 1
        if self.lang:
            self.lang = self.lang.replace("_", "-")
        self.contentparams = FeedParserDict(
            {
                "type": self.map_content_type(
                    attrs_d.get("type", default_content_type)
                ),
                "language": self.lang,
                "base": self.baseuri,
            }
        )
        self.contentparams["base64"] = self._is_base64(attrs_d, self.contentparams)
        self.push(tag, expecting_text)

    def pop_content(self, tag):
        value = self.pop(tag)
        self.incontent -= 1
        self.contentparams.clear()
        return value

    # a number of elements in a number of RSS variants are nominally plain
    # text, but this is routinely ignored.  This is an attempt to detect
    # the most common cases.  As false positives often result in silent
    # data loss, this function errs on the conservative side.
    @staticmethod
    def looks_like_html(s):
        """
        :type s: str
        :rtype: bool
        """

        # must have a close tag or an entity reference to qualify
        if not (re.search(r"</(\w+)>", s) or re.search(r"&#?\w+;", s)):
            return False

        # all tags must be in a restricted subset of valid HTML tags
        if any(
            t
            for t in re.findall(r"</?(\w+)", s)
            if t.lower() not in HTMLSanitizer.acceptable_elements
        ):
            return False

        # all entities must have been defined as valid HTML entities
        if any(
            e for e in re.findall(r"&(\w+);", s) if e not in html.entities.entitydefs
        ):
            return False

        return True

    def _map_to_standard_prefix(self, name):
        colonpos = name.find(":")
        if colonpos != -1:
            prefix = name[:colonpos]
            suffix = name[colonpos + 1 :]
            prefix = self.namespacemap.get(prefix, prefix)
            name = prefix + ":" + suffix
        return name

    def _get_attribute(self, attrs_d, name):
        return attrs_d.get(self._map_to_standard_prefix(name))

    def _is_base64(self, attrs_d, contentparams):
        if attrs_d.get("mode", "") == "base64":
            return 1
        if self.contentparams["type"].startswith("text/"):
            return 0
        if self.contentparams["type"].endswith("+xml"):
            return 0
        if self.contentparams["type"].endswith("/xml"):
            return 0
        return 1

    @staticmethod
    def _enforce_href(attrs_d):
        href = attrs_d.get("url", attrs_d.get("uri", attrs_d.get("href", None)))
        if href:
            try:
                del attrs_d["url"]
            except KeyError:
                pass
            try:
                del attrs_d["uri"]
            except KeyError:
                pass
            attrs_d["href"] = href
        return attrs_d

    def _save(self, key, value, overwrite=False):
        context = self._get_context()
        if overwrite:
            context[key] = value
        else:
            context.setdefault(key, value)

    def _get_context(self):
        if self.insource:
            context = self.sourcedata
        elif self.inimage and "image" in self.feeddata:
            context = self.feeddata["image"]
        elif self.intextinput:
            context = self.feeddata["textinput"]
        elif self.inentry:
            context = self.entries[-1]
        else:
            context = self.feeddata
        return context

    def _save_author(self, key, value, prefix="author"):
        context = self._get_context()
        context.setdefault(prefix + "_detail", FeedParserDict())
        context[prefix + "_detail"][key] = value
        self._sync_author_detail()
        context.setdefault("authors", [FeedParserDict()])
        context["authors"][-1][key] = value

    def _save_contributor(self, key, value):
        context = self._get_context()
        context.setdefault("contributors", [FeedParserDict()])
        context["contributors"][-1][key] = value

    def _sync_author_detail(self, key="author"):
        context = self._get_context()
        detail = context.get("%ss" % key, [FeedParserDict()])[-1]
        if detail:
            name = detail.get("name")
            email = detail.get("email")
            if name and email:
                context[key] = f"{name} ({email})"
            elif name:
                context[key] = name
            elif email:
                context[key] = email
        else:
            author, email = context.get(key), None
            if not author:
                return
            emailmatch = email_pattern.search(author)
            if emailmatch:
                email = emailmatch.group(0)
                # probably a better way to do the following, but it passes
                # all the tests
                author = author.replace(email, "")
                author = author.replace("()", "")
                author = author.replace("<>", "")
                author = author.replace("&lt;&gt;", "")
                author = author.strip()
                if author and (author[0] == "("):
                    author = author[1:]
                if author and (author[-1] == ")"):
                    author = author[:-1]
                author = author.strip()
            if author or email:
                context.setdefault("%s_detail" % key, detail)
            if author:
                detail["name"] = author
            if email:
                detail["email"] = email

    def _add_tag(self, term, scheme, label):
        context = self._get_context()
        tags = context.setdefault("tags", [])
        if (not term) and (not scheme) and (not label):
            return
        value = FeedParserDict(term=term, scheme=scheme, label=label)
        if value not in tags:
            tags.append(value)

    def _start_tags(self, attrs_d):
        # This is a completely-made up element. Its semantics are determined
        # only by a single feed that precipitated bug report 392 on Google Code.
        # In short, this is junk code.
        self.push("tags", 1)

    def _end_tags(self):
        for term in self.pop("tags").split(","):
            self._add_tag(term.strip(), None, None)