Build the default set of inline patterns for Markdown.

The order in which processors and/or patterns are applied is very important - e.g. if we first replace http://.../ links with <a> tags and then try to replace inline HTML, we would end up with a mess. So, we apply the expressions in the following order:

• backticks and escaped characters have to be handled before everything else so that we can preempt any markdown patterns by escaping them;

• then we handle the various types of links (auto-links must be handled before inline HTML);

• then we handle inline HTML. At this point we will simply replace all inline HTML strings with a placeholder and add the actual HTML to a stash;

• finally we apply strong, emphasis, etc.

Return a Registry instance which contains the following collection of classes with their assigned names and priorities.

Match not an image. Partial regular expression which matches if not preceded by !.

Defined Value:

NOIMG = r'(?<!\!)'

Match backtick quoted string (`e=f()` or ``e=f("`")``).

Defined Value:

BACKTICK_RE = r'(?:(?<!\\)((?:\\{2})+)(?=`+)|(?<!\\)(`+)(.+?)(?<!`)\2(?!`))'

Match a backslash escaped character (\< or \*).

Defined Value:

ESCAPE_RE = r'\\(.)'

Match emphasis with an asterisk (*emphasis*).

Defined Value:

EMPHASIS_RE = r'(\*)([^\*]+)\1'

Match strong with an asterisk (**strong**).

Defined Value:

STRONG_RE = r'(\*{2})(.+?)\1'

Match strong with underscore while ignoring middle word underscores (__smart__strong__).

Defined Value:

SMART_STRONG_RE = r'(?<!\w)(_{2})(?!_)(.+?)(?<!_)\1(?!\w)'

Match emphasis with underscore while ignoring middle word underscores (_smart_emphasis_).

Defined Value:

SMART_EMPHASIS_RE = r'(?<!\w)(_)(?!_)(.+?)(?<!_)\1(?!\w)'

Match strong emphasis with underscores (__strong _em__).

Defined Value:

SMART_STRONG_EM_RE = r'(?<!\w)(\_)\1(?!\1)(.+?)(?<!\w)\1(?!\1)(.+?)\1{3}(?!\w)'

Match emphasis strong with asterisk (***strongem*** or ***em*strong**).

Defined Value:

EM_STRONG_RE = r'(\*)\1{2}(.+?)\1(.*?)\1{2}'

Match emphasis strong with underscores (___emstrong___ or ___em_strong__).

Defined Value:

EM_STRONG2_RE = r'(_)\1{2}(.+?)\1(.*?)\1{2}'

Match strong emphasis with asterisk (***strong**em*).

Defined Value:

STRONG_EM_RE = r'(\*)\1{2}(.+?)\1{2}(.*?)\1'

Match strong emphasis with underscores (___strong__em_).

Defined Value:

STRONG_EM2_RE = r'(_)\1{2}(.+?)\1{2}(.*?)\1'

Match strong emphasis with asterisk (**strong*em***).

Defined Value:

STRONG_EM3_RE = r'(\*)\1(?!\1)([^*]+?)\1(?!\1)(.+?)\1{3}'

Match start of in-line link ([text](url) or [text](<url>) or [text](url "title")).

Defined Value:

LINK_RE = NOIMG + r'\['

Match start of in-line image link (![alttxt](url) or ![alttxt](<url>)).

Defined Value:

IMAGE_LINK_RE = r'\!\['

Match start of reference link ([Label][3]).

Defined Value:

REFERENCE_RE = LINK_RE

Match start of image reference (![alt text][2]).

Defined Value:

IMAGE_REFERENCE_RE = IMAGE_LINK_RE

Match a stand-alone * or _.

Defined Value:

NOT_STRONG_RE = r'((^|(?<=\s))(\*{1,3}|_{1,3})(?=\s|$))'

Match an automatic link (<http://www.example.com>).

Defined Value:

AUTOLINK_RE = r'<((?:[Ff]|[Hh][Tt])[Tt][Pp][Ss]?://[^<>]*)>'

Match an automatic email link (<me@example.com>).

Defined Value:

AUTOMAIL_RE = r'<([^<> !]+@[^@<> ]+)>'

Match an HTML tag (<...>).

Defined Value:

HTML_RE = (
    r'(<(\/?[a-zA-Z][^<>@ ]*( [^<>]*)?|'          # Tag
    r'!--(?:(?!<!--|-->).)*--|'                   # Comment
    r'[?](?:(?!<[?]|[?]>).)*[?]|'                 # Processing instruction
    r'!\[CDATA\[(?:(?!<!\[CDATA\[|\]\]>).)*\]\]'  # `CDATA`
    ')>)'
)

Match an HTML entity (& (decimal) or & (hex) or & (named)).

Defined Value:

ENTITY_RE = r'(&(?:\#[0-9]+|\#x[0-9a-fA-F]+|[a-zA-Z0-9]+);)'

Match two spaces at end of line.

Defined Value:

LINE_BREAK_RE = r'  \n'

Bases: NamedTuple

Emphasis/strong pattern item.

Base class that inline patterns subclass.

Inline patterns are handled by means of Pattern subclasses, one per regular expression. Each pattern object uses a single regular expression and must support the following methods: getCompiledRegExp and handleMatch.

All the regular expressions used by Pattern subclasses must capture the whole block. For this reason, they all start with ^(.*) and end with (.*)!. When passing a regular expression on class initialization, the ^(.*) and (.*)! are added automatically and the regular expression is pre-compiled.

It is strongly suggested that the newer style markdown.inlinepatterns.InlineProcessor that use a more efficient and flexible search approach be used instead. However, the older style Pattern remains for backward compatibility with many existing third-party extensions.

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• md (Markdown | None, default: None ) –

  An optional pointer to the instance of markdown.Markdown and is available as self.md on the class instance.

Methods:

• getCompiledRegExp –

  Return a compiled regular expression.

• handleMatch –

  Return a ElementTree element from the given match.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: Pattern

Base class that inline processors subclass.

This is the newer style inline processor that uses a more efficient and flexible search approach.

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• md (Markdown | None, default: None ) –

  An optional pointer to the instance of markdown.Markdown and is available as self.md on the class instance.

Methods:

• handleMatch –

  Return a ElementTree element from the given match and the

• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: Pattern

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

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• md (Markdown | None, default: None ) –

  An optional pointer to the instance of markdown.Markdown and is available as self.md on the class instance.

Methods:

• handleMatch –

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

• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: InlineProcessor

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

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• md (Markdown | None, default: None ) –

  An optional pointer to the instance of markdown.Markdown and is available as self.md on the class instance.

Methods:

• handleMatch –

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

• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: InlineProcessor

Return an escaped character.

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• md (Markdown | None, default: None ) –

  An optional pointer to the instance of markdown.Markdown and is available as self.md on the class instance.

Methods:

• handleMatch –

  If the character matched by group(1) of a pattern is in ESCAPED_CHARS

• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: Pattern

Return element of type tag with a text attribute of group(3) of a Pattern.

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• tag (str) –

  Tag of element.

Methods:

• handleMatch –

  Return Element of type tag with the string in group(3) of a

• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

Attributes:

• tag –

  The tag of the rendered element.

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

self.tag = tag

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: InlineProcessor

Return element of type tag with a text attribute of group(2) of a Pattern.

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• tag (str) –

  Tag of element.

Methods:

• handleMatch –

  Return Element of type tag with the string in group(2) of a

• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

Attributes:

• tag –

  The tag of the rendered element.

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

self.tag = tag

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: SimpleTagPattern

Return an element of type tag with no children.

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• tag (str) –

  Tag of element.

Methods:

• handleMatch –

  Return empty Element of type tag.

• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

• tag –

  The tag of the rendered element.

ANCESTOR_EXCLUDES: Collection[str] = tuple()

self.tag = tag

Bases: SimpleTagInlineProcessor

Return an element of type tag with no children.

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• tag (str) –

  Tag of element.

Methods:

• handleMatch –

  Return empty Element of type tag.

• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

• tag –

  The tag of the rendered element.

ANCESTOR_EXCLUDES: Collection[str] = tuple()

self.tag = tag

Bases: InlineProcessor

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

Methods:

• handleMatch –

  If the match contains group(3) of a pattern, then return a code

• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

Attributes:

• tag –

  The tag of the rendered element.

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

self.tag = 'code'

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: SimpleTagPattern

Return a ElementTree element nested in tag2 nested in tag1.

Useful for strong emphasis etc.

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• tag (str) –

  Tag of element.

Methods:

• handleMatch –

  Return Element in following format:

• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

• tag –

  The tag of the rendered element.

ANCESTOR_EXCLUDES: Collection[str] = tuple()

self.tag = tag

Bases: SimpleTagInlineProcessor

Return a ElementTree element nested in tag2 nested in tag1.

Useful for strong emphasis etc.

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• tag (str) –

  Tag of element.

Methods:

• handleMatch –

  Return Element in following format:

• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

• tag –

  The tag of the rendered element.

ANCESTOR_EXCLUDES: Collection[str] = tuple()

self.tag = tag

Bases: InlineProcessor

Store raw inline html and return a placeholder.

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• md (Markdown | None, default: None ) –

  An optional pointer to the instance of markdown.Markdown and is available as self.md on the class instance.

Methods:

• handleMatch –

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

• unescape –

  Return unescaped text given text with an inline placeholder.

• backslash_unescape –

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

• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: InlineProcessor

Emphasis processor for handling strong and em matches inside asterisks.

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• md (Markdown | None, default: None ) –

  An optional pointer to the instance of markdown.Markdown and is available as self.md on the class instance.

Methods:

• build_single –

  Return single tag.

• build_double –

  Return double tag.

• build_double2 –

  Return double tags (variant 2): <strong>text <em>text</em></strong>.

• parse_sub_patterns –

  Parses sub patterns.

• build_element –

  Element builder.

• handleMatch –

  Parse patterns.

• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

Attributes:

• PATTERNS –

  The various strong and emphasis patterns handled by this processor.

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

PATTERNS = [
    EmStrongItem(re.compile(EM_STRONG_RE, re.DOTALL | re.UNICODE), 'double', 'strong,em'),
    EmStrongItem(re.compile(STRONG_EM_RE, re.DOTALL | re.UNICODE), 'double', 'em,strong'),
    EmStrongItem(re.compile(STRONG_EM3_RE, re.DOTALL | re.UNICODE), 'double2', 'strong,em'),
    EmStrongItem(re.compile(STRONG_RE, re.DOTALL | re.UNICODE), 'single', 'strong'),
    EmStrongItem(re.compile(EMPHASIS_RE, re.DOTALL | re.UNICODE), 'single', 'em')
]

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: AsteriskProcessor

Emphasis processor for handling strong and em matches inside underscores.

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• md (Markdown | None, default: None ) –

  An optional pointer to the instance of markdown.Markdown and is available as self.md on the class instance.

Methods:

• getCompiledRegExp –

  Return a compiled regular expression.

• handleMatch –

  Parse patterns.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

• build_single –

  Return single tag.

• build_double –

  Return double tag.

• build_double2 –

  Return double tags (variant 2): <strong>text <em>text</em></strong>.

• parse_sub_patterns –

  Parses sub patterns.

• build_element –

  Element builder.

Attributes:

• PATTERNS –

  The various strong and emphasis patterns handled by this processor.

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

PATTERNS = [
    EmStrongItem(re.compile(EM_STRONG2_RE, re.DOTALL | re.UNICODE), 'double', 'strong,em'),
    EmStrongItem(re.compile(STRONG_EM2_RE, re.DOTALL | re.UNICODE), 'double', 'em,strong'),
    EmStrongItem(re.compile(SMART_STRONG_EM_RE, re.DOTALL | re.UNICODE), 'double2', 'strong,em'),
    EmStrongItem(re.compile(SMART_STRONG_RE, re.DOTALL | re.UNICODE), 'single', 'strong'),
    EmStrongItem(re.compile(SMART_EMPHASIS_RE, re.DOTALL | re.UNICODE), 'single', 'em')
]

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: InlineProcessor

Return a link element from the given match.

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• md (Markdown | None, default: None ) –

  An optional pointer to the instance of markdown.Markdown and is available as self.md on the class instance.

Methods:

• handleMatch –

  Return an a Element or (None, None, None).

• getLink –

  Parse data between () of [Text]() allowing recursive ().

• getText –

  Parse the content between [] of the start of an image or link

• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: LinkInlineProcessor

Return a img element from the given match.

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• md (Markdown | None, default: None ) –

  An optional pointer to the instance of markdown.Markdown and is available as self.md on the class instance.

Methods:

• handleMatch –

  Return an img Element or (None, None, None).

• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

• getLink –

  Parse data between () of [Text]() allowing recursive ().

• getText –

  Parse the content between [] of the start of an image or link

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: LinkInlineProcessor

Match to a stored reference and return link element.

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• md (Markdown | None, default: None ) –

  An optional pointer to the instance of markdown.Markdown and is available as self.md on the class instance.

Methods:

• handleMatch –

  Return Element returned by makeTag method or (None, None, None).

• evalId –

  Evaluate the id portion of [ref][id].

• makeTag –
• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

• getLink –

  Parse data between () of [Text]() allowing recursive ().

• getText –

  Parse the content between [] of the start of an image or link

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: ReferenceInlineProcessor

Short form of reference: [google].

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• md (Markdown | None, default: None ) –

  An optional pointer to the instance of markdown.Markdown and is available as self.md on the class instance.

Methods:

• evalId –

  Evaluate the id of [ref].

• getCompiledRegExp –

  Return a compiled regular expression.

• handleMatch –

  Return Element returned by makeTag method or (None, None, None).

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

• getLink –

  Parse data between () of [Text]() allowing recursive ().

• getText –

  Parse the content between [] of the start of an image or link

• makeTag –

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: ReferenceInlineProcessor

Match to a stored reference and return img element.

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• md (Markdown | None, default: None ) –

  An optional pointer to the instance of markdown.Markdown and is available as self.md on the class instance.

Methods:

• makeTag –
• getCompiledRegExp –

  Return a compiled regular expression.

• handleMatch –

  Return Element returned by makeTag method or (None, None, None).

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

• getLink –

  Parse data between () of [Text]() allowing recursive ().

• getText –

  Parse the content between [] of the start of an image or link

• evalId –

  Evaluate the id portion of [ref][id].

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: ImageReferenceInlineProcessor

Short form of image reference: ![ref].

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• md (Markdown | None, default: None ) –

  An optional pointer to the instance of markdown.Markdown and is available as self.md on the class instance.

Methods:

• evalId –

  Evaluate the id of [ref].

• getCompiledRegExp –

  Return a compiled regular expression.

• handleMatch –

  Return Element returned by makeTag method or (None, None, None).

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

• getLink –

  Parse data between () of [Text]() allowing recursive ().

• getText –

  Parse the content between [] of the start of an image or link

• makeTag –

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: InlineProcessor

Return a link Element given an auto-link (<http://example/com>).

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• md (Markdown | None, default: None ) –

  An optional pointer to the instance of markdown.Markdown and is available as self.md on the class instance.

Methods:

• handleMatch –

  Return an a Element of group(1).

• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

ANCESTOR_EXCLUDES: Collection[str] = tuple()

Bases: InlineProcessor

Return a mailto link Element given an auto-mail link (<foo@example.com>).

Parameters:

• pattern (str) –

  A regular expression that matches a pattern.

• md (Markdown | None, default: None ) –

  An optional pointer to the instance of markdown.Markdown and is available as self.md on the class instance.

Methods:

• handleMatch –

  Return an Element containing a mailto link of group(1).

• getCompiledRegExp –

  Return a compiled regular expression.

• type –

  Return class name, to define pattern type

• unescape –

  Return unescaped text given text with an inline placeholder.

Attributes:

• ANCESTOR_EXCLUDES (Collection[str]) –

  A collection of elements which are undesirable ancestors. The processor will be skipped if it

ANCESTOR_EXCLUDES: Collection[str] = tuple()