"""

inlinePatterns = util.Registry()

inlinePatterns.register(BacktickInlineProcessor(BACKTICK_RE), 'backtick', 190)

inlinePatterns.register(EscapeInlineProcessor(ESCAPE_RE, md), 'escape', 180)

inlinePatterns.register(ReferenceInlineProcessor(REFERENCE_RE, md), 'reference', 170)

inlinePatterns.register(LinkInlineProcessor(LINK_RE, md), 'link', 160)

inlinePatterns.register(ImageInlineProcessor(IMAGE_LINK_RE, md), 'image_link', 150)

inlinePatterns.register(

ImageReferenceInlineProcessor(IMAGE_REFERENCE_RE, md), 'image_reference', 140

)

inlinePatterns.register(

ShortReferenceInlineProcessor(REFERENCE_RE, md), 'short_reference', 130

)

inlinePatterns.register(

ShortImageReferenceInlineProcessor(IMAGE_REFERENCE_RE, md), 'short_image_ref', 125

)

inlinePatterns.register(AutolinkInlineProcessor(AUTOLINK_RE, md), 'autolink', 120)

inlinePatterns.register(AutomailInlineProcessor(AUTOMAIL_RE, md), 'automail', 110)

inlinePatterns.register(SubstituteTagInlineProcessor(LINE_BREAK_RE, 'br'), 'linebreak', 100)

inlinePatterns.register(HtmlInlineProcessor(HTML_RE, md), 'html', 90)

inlinePatterns.register(HtmlInlineProcessor(ENTITY_RE, md), 'entity', 80)

inlinePatterns.register(DelimiterProcessor('*', 'strong,em', md), 'em_strong', 60)

md.delimiters.add('_', 'strong,em', smart=True)

# Tag

r'''(<(\/?+[a-zA-Z][^\s"'<>@]*+(?:\s+[^\s"'=<>]++(?:\s*+=\s*+(?:"[^"]*+"|'[^']*+'|[^\s"'=<>]++))?+)*+\s*+/?|'''

# Comment

r'!--(?:(?!<!--|-->).)*--|'

# Processing instruction

r'[?](?:(?!<[?]|[?]>).)*[?]|'

# `CDATA`

r'!\[CDATA\[(?:(?!<!\[CDATA\[|\]\]>).)*\]\]'

')>)'

"""Remove quotes from around a string."""

if ((string.startswith('"') and string.endswith('"')) or

(string.startswith("'") and string.endswith("'"))):

return string[1:-1]

else:

"""Emphasis/strong pattern item."""

pattern: re.Pattern[str]

builder: str

"""

ANCESTOR_EXCLUDES: Collection[str] = tuple()

"""

compiled_re: re.Pattern[str]

md: Markdown | None

def __init__(self, pattern: str, md: Markdown | None = None):

"""

self.pattern = pattern

self.compiled_re = re.compile(r"^(.*?)%s(.*)$" % pattern,

re.DOTALL | re.UNICODE)

self.md = md

def getCompiledRegExp(self) -> re.Pattern:

""" Return a compiled regular expression. """

return self.compiled_re

def handleMatch(self, m: re.Match[str]) -> etree.Element | str:

"""Return a ElementTree element from the given match.

pass # pragma: no cover

def type(self) -> str:

""" Return class name, to define pattern type """

return self.__class__.__name__

def unescape(self, text: str) -> str:

""" Return unescaped text given text with an inline placeholder. """

try:

stash = self.md.treeprocessors['inline'].stashed_nodes

except KeyError: # pragma: no cover

return text

def get_stash(m):

id = m.group(1)

if id in stash:

value = stash.get(id)

if isinstance(value, str):

return value

else:

# An `etree` Element - return text content only

return ''.join(value.itertext())

"""

def __init__(self, pattern: str, md: Markdown | None = None):

"""

self.pattern = pattern

self.compiled_re = re.compile(pattern, re.DOTALL | re.UNICODE)

# API for Markdown to pass `safe_mode` into instance

self.safe_mode = False

self.md = md

def handleMatch(self, m: re.Match[str], data: str) -> tuple[etree.Element | str | None, int | None, int | None]:

"""Return a ElementTree element from the given match and the

""" Return a simple text of `group(2)` of a Pattern. """

def handleMatch(self, m: re.Match[str]) -> str:

""" Return string content of `group(2)` of a matching pattern. """

""" Return a simple text of `group(1)` of a Pattern. """

def handleMatch(self, m: re.Match[str], data: str) -> tuple[str, int, int]:

""" Return string content of `group(1)` of a matching pattern. """

""" Return an escaped character. """

def handleMatch(self, m: re.Match[str], data: str) -> tuple[str | None, int, int]:

"""

char = m.group(1)

if char in self.md.ESCAPED_CHARS:

return '{}{}{}'.format(util.STX, ord(char), util.ETX), m.start(0), m.end(0)

else:

"""

def __init__(self, pattern: str, tag: str):

"""

Pattern.__init__(self, pattern)

self.tag = tag

""" The tag of the rendered element. """

def handleMatch(self, m: re.Match[str]) -> etree.Element:

"""

el = etree.Element(self.tag)

el.text = m.group(3)

"""

def __init__(self, pattern: str, tag: str):

"""

InlineProcessor.__init__(self, pattern)

self.tag = tag

""" The tag of the rendered element. """

def handleMatch(self, m: re.Match[str], data: str) -> tuple[etree.Element, int, int]: # pragma: no cover

"""

el = etree.Element(self.tag)

el.text = m.group(2)

""" Return an element of type `tag` with no children. """

def handleMatch(self, m: re.Match[str]) -> etree.Element:

""" Return empty [`Element`][xml.etree.ElementTree.Element] of type `tag`. """

""" Return an element of type `tag` with no children. """

def handleMatch(self, m: re.Match[str], data: str) -> tuple[etree.Element, int, int]:

""" Return empty [`Element`][xml.etree.ElementTree.Element] of type `tag`. """

""" Return a `<code>` element containing the escaped matching text. """

def __init__(self, pattern: str):

InlineProcessor.__init__(self, pattern)

self.ESCAPED_BSLASH = '{}{}{}'.format(util.STX, ord('\\'), util.ETX)

self.tag = 'code'

""" The tag of the rendered element. """

def find_code_spans(self, start: int, text: str) -> tuple[int, int] | None:

"""Find code spans."""

last = len(text)

# Get the maximum starting ticks

max_ticks = 0

while start < last and text[start] == '`':

max_ticks += 1

start += 1

if not max_ticks: # pragma: no cover

# This is not ever expected to happen.

return None

longest_span = 0

end = 0

# Find an ending span of backticks that matches our opening

i = start

while i < last:

span_length = 0

while i < last and text[i] == '`':

span_length += 1

i += 1

if not span_length:

i += 1

continue

# Did we find the end?

if max_ticks == span_length:

return start, i - span_length

# Track the longest span of backticks we find as a fallback.

if span_length > longest_span:

longest_span = span_length

end = i

# Since we didn't find an exact matching start and end,

# adjust start to match the largest end we could calculate.

if longest_span:

return start - (max_ticks - longest_span), end - longest_span

# We could not find a suitable pairing

return None

def handleMatch(self, m: re.Match[str], data: str) -> tuple[etree.Element | str | None, int | None, int | None]:

"""

if m.group(1):

return m.group(1).replace('\\\\', self.ESCAPED_BSLASH), m.start(0), m.end(0)

begin = m.start(0)

result = self.find_code_spans(begin, data)

if result is not None:

start, end = result

el = etree.Element(self.tag)

el.text = util.AtomicString(util.code_escape(data[start:end].strip()))

return el, begin, result[1] + (start - begin)

"""Return a ElementTree element nested in tag2 nested in tag1.

def handleMatch(self, m: re.Match[str]) -> etree.Element:

"""

tag1, tag2 = self.tag.split(",")

el1 = etree.Element(tag1)

el2 = etree.SubElement(el1, tag2)

el2.text = m.group(3)

if len(m.groups()) == 5:

el2.tail = m.group(4)

"""Return a ElementTree element nested in tag2 nested in tag1.

def handleMatch(self, m: re.Match[str], data: str) -> tuple[etree.Element, int, int]: # pragma: no cover

"""

tag1, tag2 = self.tag.split(",")

el1 = etree.Element(tag1)

el2 = etree.SubElement(el1, tag2)

el2.text = m.group(2)

if len(m.groups()) == 3:

el2.tail = m.group(3)

""" Store raw inline html and return a placeholder. """

def handleMatch(self, m: re.Match[str], data: str) -> tuple[str, int, int]:

""" Store the text of `group(1)` of a pattern and return a placeholder string. """

rawhtml = self.backslash_unescape(self.unescape(m.group(1)))

place_holder = self.md.htmlStash.store(rawhtml)

return place_holder, m.start(0), m.end(0)

def unescape(self, text: str) -> str:

""" Return unescaped text given text with an inline placeholder. """

try:

stash = self.md.treeprocessors['inline'].stashed_nodes

except KeyError: # pragma: no cover

return text

def get_stash(m: re.Match[str]) -> str:

id = m.group(1)

value = stash.get(id)

if value is not None:

if isinstance(value, etree.Element):

# Ensure we don't have a placeholder inside a placeholder

return self.unescape(self.md.serializer(value))

else:

return r'\%s' % value

return util.INLINE_PLACEHOLDER_RE.sub(get_stash, text)

def backslash_unescape(self, text: str) -> str:

""" Return text with backslash escapes undone (backslashes are restored). """

try:

RE = self.md.treeprocessors['unescape'].RE

except KeyError: # pragma: no cover

return text

def _unescape(m: re.Match[str]) -> str:

return chr(int(m.group(1)))

"""Delimiter."""

def __init__(self, token: str, tags: str, smart: bool, double: bool):

"""Initialize."""

self.stack: deque[tuple[int, int, bool, int]] = deque()

temp = tags.split(',')

self.tag_count = len(temp)

self.tags: tuple[str, str] = (temp[0], temp[1]) if self.tag_count == 2 else (temp[0], temp[0])

self.double = len(temp) != 2 and double

self.single = len(temp) != 2 and not double

self.smart = smart

self._build_patterns(token)

def _build_patterns(self, token: str) -> str:

"""Build regular expression patterns."""

# Build up patterns

self.token = token

etoken = re.escape(token)

# Avoid at start and end

xstart = fr'(?:(?<=_)|(?<![\w{etoken}]))' if token != '_' else fr'(?<![\w{etoken}])'

xend = fr'(?:(?=_)|(?![\w{etoken}]))' if token != '_' else fr'(?![\w{etoken}])'

self.max_size = 2

if self.tag_count != 2 and not self.double:

self.max_size = 1

# Patterns for "smart" cases.

if self.smart:

self.boundary = re.compile(

fr'''(?x)

''',

flags=re.UNICODE

)

# Patterns for "dumb" cases.

else:

self.boundary = re.compile(

fr'''(?x)

''',

flags=re.UNICODE

)

self.bad = re.compile(fr'{etoken}+')

return fr'{etoken}'

def reset(self) -> None:

"""Reset."""

# Cache info

"""Processor for handling complex nested patterns such as strong and em matches."""

SPACE = re.compile(r'\s')

def __init__(

self,

token: str,

tags: str,

md: Markdown,

smart: bool = False,

double: bool = False

) -> None:

"""Initialize."""

md.delimiters = self

self.regions: list[tuple[int, int, int, int, tuple[str, str], int]] = []

self.stack: list[tuple[int, int, bool, int]] = []

self.tokens: list[str] = []

self.delimiters: dict[str, Delimiter] = {}

self.cache_index = 0

self.cache_pos = 0

self.md = md

# API for Markdown to pass `safe_mode` into instance

self.safe_mode = False

self.add(token, tags, smart, double)

def add(

self,

token: str,

tags: str,

smart: bool = False,

double: bool = False

) -> None:

"""Add a delimiter."""

if token not in self.tokens:

self.tokens.append(token)

self.delimiters[token] = Delimiter(token, tags, smart, double)

self.pattern = '|'.join([re.escape(t) for t in self.tokens])

self.compiled_re = re.compile(self.pattern, re.DOTALL | re.UNICODE)

def remove(self, token: str) -> None:

"""Remove a token."""

try:

i = self.tokens.index(token)

del self.tokens[i]

del self.delimiters[token]

except Exception:

pass

self.pattern = '|'.join([re.escape(t) for t in self.tokens])

self.compiled_re = re.compile(self.pattern, re.DOTALL | re.UNICODE) if self.pattern else re.compile(r'(?!)')

def reset(self) -> None:

"""Reset."""

# Cache info

for v in self.delimiters.values():

v.reset()

self.regions.clear()

self.stack.clear()

self.cache_index = 0

self.cache_pos = 0

def _build_element(

self,

data: str,

start: int = 0,

offset: int = 0

) -> tuple[etree.Element, int]:

"""Element builder."""

regions = self.regions

el: etree.Element | None = None

last: Any = None

previous: Any = None

outer: list[etree.Element] = []

outer_r: list[tuple[int, int, int, int, tuple[str, str], int]] = []

# Iterate regions creating the elements they represent

end = len(regions)

idx = 0

for idx, i in enumerate(range(start, end), 1):

r = regions[i]

# Not contained within region

if idx and r[0] >= regions[start][3]:

idx -= 1

break

# Get the appropriate element(s)

if r[-1] == 2:

el1 = etree.Element(r[4][0])

else:

el1 = etree.Element(r[4][1])

# Populate the elements with their text

if idx > 1:

if last.text is None:

if previous[2] < r[0]:

last.text = data[previous[1]+offset:previous[2]+offset]

else:

last.text = data[previous[1]+offset:r[0]+offset]

if last is not outer[-1] and last.tail is None:

if r[0] < outer_r[-1][3]:

last.tail = data[previous[3]+offset:r[0]+offset]

else:

last.tail = data[previous[3]+offset:outer_r[-1][2]+offset]

outer[-1].tail = data[outer_r[-1][3]+offset:r[0]+offset]

# First element

if el is None:

el = el1

last = el

outer.append(el)

outer_r.append(r)

# Subsequent elements

else:

# Is the current outer element no longer wrapping this one?

while len(outer_r) > 1 and r[3] > outer_r[-1][3]:

outer.pop()

outer_r.pop()

# Non-nested

else:

outer[-1].append(el1)

# Is this element wrapping the next?

if i + 1 < end:

if r[3] > regions[i + 1][3]:

outer.append(el1)

outer_r.append(r)

# Track the last element we parsed.

last = el1

# Track the previous region.

previous = r

# Populate remaining elements with their text

while outer:

if last.text is None:

last.text = data[previous[1]+offset:previous[2]+offset]

if last.tail is None and last is not outer[-1]:

last.tail = data[previous[3]+offset:outer_r[-1][2]+offset]

last = outer.pop()

previous = outer_r.pop()

return cast('etree.Element', el), idx

def increment_next_position(self, start: int, count: int) -> None:

"""

# Determine next offset

self.cache_index += count

if self.cache_index < len(self.regions):

self.cache_pos = self.regions[self.cache_index][0]

while self.stack:

entry = self.stack.pop(0)

if start < entry[0] <= self.cache_pos:

self.cache_pos = entry[0]

break

# Nothing left to process

else:

self.reset()

def get_cached_result(self, pos: int, data: str) -> tuple[etree.Element, int, int]:

"""Get a cached result."""

# Process the next region(s) in the cache

regions = self.regions

offset = pos - self.cache_pos if pos != self.cache_pos else pos - regions[self.cache_index][0]

start, end = regions[self.cache_index][0], regions[self.cache_index][3]

el, count = self._build_element(data, self.cache_index, offset)

self.increment_next_position(start, count)

return el, start + offset, end + offset

def get_match(self, data: str, start: int) -> re.Match[str] | None:

"""Get match."""

for d in self.delimiters.values():

m = d.boundary.match(data, start)

if m is not None:

return m

return None

def search(self, data: str, start: int) -> re.Match[str] | None:

"""Search."""

for i in range(start, len(data)):

if data[i] in self.delimiters:

d = self.delimiters[data[i]]

m = d.boundary.match(data, i)

if m is not None:

if not d.stack and m.lastgroup[0] == 'e': # type: ignore[index]

continue

return m

return None

def add_region(self, delim: Delimiter, a: int, b: int, c: int, d: int, size: int) -> None:

"""Add region."""

self.regions.append((a, b, c, d, delim.tags, size))

for delim in self.delimiters.values():

while delim.stack:

p = delim.stack[-1][0]

if max(p, a) <= min(p, d - 1):

delim.stack.pop()

continue

break

def handleMatch( # type: ignore[override]

self,

m: re.Match[str],

data: str

) -> tuple[etree.Element | None, int | None, int | None]:

"""Parse delimiter pattern."""

# Do we have entries we haven't returned yet?

if self.regions:

return self.get_cached_result(m.start(0), data)

# If token is not an opening, quit

m2 = self.get_match(data, m.start(0))

if m2 is None or m2.lastgroup[0] == 'e': # type: ignore[index]

if m2 is None:

delim = self.delimiters[m.group(0)]

m2 = delim.bad.match(data, m.start(0))

# Advance past the full length of the delimiter found

return None, m2.start(0), m2.end(0)

# Get the stack and regions

token = data[m.start(0)]

delim = self.delimiters[token]

stack = delim.stack

start = m2.start(0)

end = m2.end(0)

length = end - start

# Double needs at least a size of 2

if delim.double and length < 2:

return None, m.start(0), m.end(0)

is_ambiguous = m2.lastgroup[0] != 's' # type: ignore[index]

stack.append((start, start + length, is_ambiguous, length))

# Pair tokens until the stack is empty or we can no longer find tokens.

while any(d.stack for d in self.delimiters.values()):

m2 = self.search(data, end)

if m2 is None:

break

token = data[m2.start(0)]

delim = self.delimiters[token]

stack = delim.stack

start = m2.start(0)

end = m2.end(0)

# Get current and last delimiter size

current = len(m2.group(0))

# Some delimiters may be ambiguous and look like both a start or an end

is_start = m2.lastgroup[0] != 'e' # type: ignore[index]

is_end = not is_start or m2.lastgroup[0] != 's' # type: ignore[index]

is_ambiguous = is_start and is_end

last = stack[-1][-1] if stack else 0

# Find closing tokens

# Looking for:

# - `*em*`

# - `**strong**`

# - `***strong,em***`

# - `*em**`

# - `*em***`

# - `**strong***`

#

# Avoid ambiguous tokens that could be a start or an end.

# Consume starts until the end token is fully consumed.

# If we don't consume the entire end, see if next rule consumes it.

if stack and is_end and ((not is_ambiguous and current > last) or current == last or current >= 3):

is_start = False

# Consume previous points until the delimiter is consumed

original = current

while stack and current and last <= current:

delimiter = stack.pop()

# Build up region for pair and adjust accounting.

size = min(delimiter[-1], 1 if delim.tag_count == 2 and delimiter[-1] == 3 else delim.max_size)

self.add_region(delim, delimiter[1] - size, delimiter[1], start, start + size, size)

start += size

current -= size

new = 0

if size < delimiter[-1] and (not delim.double or (delimiter[-1] - size) != 1):

new = delimiter[-1] - size

stack.append((delimiter[0], delimiter[1] - size, delimiter[2], new))

if not stack:

if any(d.stack for d in self.delimiters.values() if d is not delim):

delim.reset()

continue

is_end = False

break

last = stack[-1][-1]

# Should remainder be treated as a new start?

if original >= 3 and current and is_ambiguous:

delim.stack.append((m2.start(0) + (original - current), end, False, current))

is_end = False

# Do we still have more to consume?

else:

is_end = current and stack and last > current

# Looking for:

# - `***em*`

# - `***strong**`

# - `**em*`

if stack and is_end and (last >= 3 or not is_ambiguous) and last > current:

delimiter = stack.pop()

# Don't pair with an ambiguous opening

while stack and delimiter[-1] != 3 and delimiter[2]:

delimiter = stack.pop()

last = delimiter[-1]

if delimiter[2] and delimiter[-1] != 3:

if any(d.stack for d in self.delimiters.values() if d is not delim):

delim.reset()

continue

break

# Create new regions

is_start = False

ds, de = delimiter[:2]

while current and (not delim.double or current != 1):

size = min(current, 1 if delim.tag_count == 2 and current == 3 else delim.max_size)

new = last - size

self.add_region(delim, ds + new, de, start, start + size, size)

start += size

current -= size

last -= size

de -= size

if last and (not delim.double or last > 1):

stack.append((ds, de, False, last))

# Find opening tokens

# Looking for:

# - `*em ...*`

# - `**strong ...*`

# - `***em ...*`

if is_start and (not delim.double or current != 1):

stack.append((start, end, is_ambiguous, current))

# Combine the stacks and order them

for delim in self.delimiters.values():

self.stack.extend(delim.stack)

self.stack.sort(key=lambda x: x[0])

# Build the HTML elements

if self.regions:

# Regions may be out of order.

self.regions.sort(key=lambda x: x[0])