The xparse package

Document command parser

The LATEX3 Project∗

Released 2017/04/01

The xparse package provides a high-level interface for producing document-level com-
mands. In that way, it is intended as a replacement for the LATEX 2ε \newcommand macro.
However, xparse works so that the interface to a function (optional arguments, stars
and mandatory arguments, for example) is separate from the internal implementation.
xparse provides a normalised input for the internal form of a function, independent of the
document-level argument arrangement.
At present, the functions in xparse which are regarded as “stable” are:
• \NewDocumentCommand

• \RenewDocumentCommand
• \ProvideDocumentCommand
• \DeclareDocumentCommand
• \NewDocumentEnvironment

• \RenewDocumentEnvironment
• \ProvideDocumentEnvironment
• \DeclareDocumentEnvironment

• \NewExpandableDocumentCommand
• \RenewExpandableDocumentCommand
• \ProvideExpandableDocumentCommand
• \DeclareExpandableDocumentCommand

• \IfNoValue(TF)
• \IfValue(TF)
• \IfBoolean(TF)

with the other functions currently regarded as “experimental”. Please try all of the com-
mands provided here, but be aware that the experimental ones may change or disappear.
∗ E-mail: latex-team@latex-project.org

1
0.1 Specifying arguments
Before introducing the functions used to create document commands, the method for
specifying arguments with xparse will be illustrated. In order to allow each argument to
be defined independently, xparse does not simply need to know the number of arguments
for a function, but also the nature of each one. This is done by constructing an argument
specification, which defines the number of arguments, the type of each argument and
any additional information needed for xparse to read the user input and properly pass it
through to internal functions.
The basic form of the argument specifier is a list of letters, where each letter defines
a type of argument. As will be described below, some of the types need additional
information, such as default values. The argument types can be divided into two, those
which define arguments that are mandatory (potentially raising an error if not found)
and those which define optional arguments. The mandatory types are:

m A standard mandatory argument, which can either be a single token alone or mul-
tiple tokens surrounded by curly braces. Regardless of the input, the argument will
be passed to the internal code surrounded by a brace pair. This is the xparse type
specifier for a normal TEX argument.
l An argument which reads everything up to the first open group token: in standard
LATEX this is a left brace.
r Reads a “required” delimited argument, where the delimiters are given as htoken1 i
and htoken2 i: rhtoken1 ihtoken2 i. If the opening htokeni is missing, the default
marker -NoValue- will be inserted after a suitable error.

R As for r, this is a “required” delimited argument but has a user-definable recovery

hdefaulti, given as Rhtoken1 ihtoken2 i{hdefaulti}.
u Reads an argument “until” htokensi are encountered, where the desired htokensi
are given as an argument to the specifier: u{htokensi}.
v Reads an argument “verbatim”, between the following character and its next oc-
currence, in a way similar to the argument of the LATEX 2ε command \verb. Thus
a v-type argument is read between two matching tokens, which cannot be any of %,
\, #, {, } or ␣. The verbatim argument can also be enclosed between braces, { and
}. A command with a verbatim argument will not work when it appears within an
argument of another function.

The types which define optional arguments are:

o A standard LATEX optional argument, surrounded with square brackets, which will
supply the special -NoValue- marker if not given (as described later).
d An optional argument which is delimited by htoken1 i and htoken2 i, which are given
as arguments: dhtoken1 ihtoken2 i. As with o, if no value is given the special marker
-NoValue- is returned.
O As for o, but returns hdefaulti if no value is given. Should be given as O{hdefaulti}.
D As for d, but returns hdefaulti if no value is given: Dhtoken1 ihtoken2 i{hdefaulti}.
Internally, the o, d and O types are short-cuts to an appropriated-constructed D
type argument.

2
 s An optional star, which will result in a value \BooleanTrue if a star is present and
\BooleanFalse otherwise (as described later).
t An optional htokeni, which will result in a value \BooleanTrue if htokeni is present
and \BooleanFalse otherwise. Given as thtokeni.
g An optional argument given inside a pair of TEX group tokens (in standard LATEX,
{ . . . }), which returns -NoValue- if not present.
G As for g but returns hdefaulti if no value is given: G{hdefaulti}.
e An optional set of embellishments, each of which requires a value. If a key is not
present, -NoValue- is returned. The returned data is a token list comprising one
braced entry per key, ordered as for the key list in the argument specification. Given
as e{htokensi}. All htokensi must be distinct. This is an experimental type.
E As for e but returns one or more hdefaultsi if values are not given: E{htokensi}{hdefaultsi}.
See Section 0.6 for more details.
Using these specifiers, it is possible to create complex input syntax very easily. For
example, given the argument definition ‘s o o m O{default}’, the input ‘*[Foo]{Bar}’
would be parsed as:
• #1 = \BooleanTrue
• #2 = Foo
• #3 = -NoValue-
• #4 = Bar
• #5 = default
whereas ‘[One][Two]{}[Three]’ would be parsed as:
• #1 = \BooleanFalse
• #2 = One
• #3 = Two
• #4 =
• #5 = Three
Delimited argument types (d, o and r) are defined such that they require matched
pairs of delimiters when collecting an argument. For example
\NewDocumentCommand{\foo}{o}{#1}
\foo[[content]] % #1 = "[content]"
\foo[[] % Error: missing closing "]"
Also note that { and } cannot be used as delimiters as they are used by TEX as grouping
tokens. Arguments to be grabbed inside these tokens must be created as either m- or
g-type arguments.
Within delimited arguments, non-balanced or otherwise awkward tokens may be
included by protecting the entire argument with a brace pair
\NewDocumentCommand{\foobar}{o}{#1}
\foobar[{[}] % Allowed as the "[" is ’hidden’
These braces will be stripped if they surround the entire content of the optional argument
\NewDocumentCommand{\foobaz}{o}{#1}
\foobaz[{abc}] % => "abc"
\foobaz[ {abc}] % => " {abc}"

3
 Two more tokens have a special meaning when creating an argument specifier. First,
+ is used to make an argument long (to accept paragraph tokens). In contrast to
LATEX 2ε ’s \newcommand, this applies on an argument-by-argument basis. So modify-
ing the example to ‘s o o +m O{default}’ means that the mandatory argument is now
\long, whereas the optional arguments are not.
Secondly, the token > is used to declare so-called “argument processors”, which
can be used to modify the contents of an argument before it is passed to the macro
definition. The use of argument processors is a somewhat advanced topic, (or at least a
less commonly used feature) and is covered in Section 0.9.
When an optional argument is followed by a mandatory argument with the same
delimiter, xparse issues a warning because the optional argument could not be omitted
by the user, thus becoming in effect mandatory. This applies to o, d, O, D, s, t, e, and
E type arguments followed by r or R-type required arguments, but also to g or G type
arguments followed by m type arguments.

0.2 Spacing and optional arguments

TEX will find the first argument after a function name irrespective of any intervening
spaces. This is true for both mandatory and optional arguments. So \foo[arg] and
\foo␣␣␣[arg] are equivalent. Spaces are also ignored when collecting arguments up to
the last mandatory argument to be collected (as it must exist). So after

\NewDocumentCommand \foo { m o m } { ... }

the user input \foo{arg1}[arg2]{arg3} and \foo{arg1}␣␣[arg2]␣␣␣{arg3} will both
be parsed in the same way. However, spaces are not ignored when parsing optional
arguments after the last mandatory argument. Thus with

\NewDocumentCommand \foobar { m o } { ... }

\foobar{arg1}[arg2] will find an optional argument but \foobar{arg1}␣[arg2] will
not. This is so that trailing optional arguments are not picked up “by accident” in input.
There is one major exception to the rules listed above: when xparse is used to define
what TEX defines as “control symbols” in which the function name is made up of a single
character, such as “\\”, spaces are not ignored directly after them even for mandatory
arguments.

0.3 Required delimited arguments

The contrast between a delimited (D-type) and “required delimited” (R-type) argument
is that an error will be raised if the latter is missing. Thus for example

\NewDocumentCommand {\foobaz} {r()m} {}

\foobaz{oops}
will lead to an error message being issued. The marker -NoValue- (r-type) or user-
specified default (for R-type) will be inserted to allow error recovery.
Users should note that support for required delimited arguments is somewhat ex-
perimental. Feedback is therefore very welcome on the LaTeX-L mailing list.

4
0.4 Verbatim arguments
Arguments of type v are read in verbatim mode, which will result in the grabbed argument
consisting of tokens of category codes 12 (“other”) and 13 (“active”), except spaces, which
are given category code 10 (“space”). The argument is delimited in a similar manner to
the LATEX 2ε \verb function, or by (correctly nested) pairs of braces.
Functions containing verbatim arguments cannot appear in the arguments of other
functions. The v argument specifier includes code to check this, and will raise an error if
the grabbed argument has already been tokenized by TEX in an irreversible way.
By default, an argument of type v must be at most one line. Prefixing with + allows
line breaks within the argument.
Users should note that support for verbatim arguments is somewhat experimental.
Feedback is therefore very welcome on the LaTeX-L mailing list.

0.5 Default values of arguments

Uppercase argument types (O, D, . . . ) allow to specify a default value to be used when
the argument is missing; their lower-case counterparts use the special marker -NoValue-.
The default value can be expressed in terms of the value of any other arguments by using
#1, #2, and so on.

\NewDocumentCommand {\conjugate} { m O{#1ed} O{#2} } {(#1,#2,#3)}

\conjugate {walk} % => (walk,walked,walked)
\conjugate {find} [found] % => (find,found,found)
\conjugate {do} [did] [done] % => (do,did,done)
The default values may refer to arguments that appear later in the argument specification.
For instance a command could accept two optional arguments, equal by default:

\NewDocumentCommand {\margins} { O{#3} m O{#1} m } {(#1,#2,#3,#4)}

\margins {a} {b} % => {(-NoValue-,a,-NoValue-,b)}
\margins [1cm] {a} {b} % => {(1cm,a,1cm,b)}
\margins {a} [1cm] {b} % => {(1cm,a,1cm,b)}
\margins [1cm] {a} [2cm] {b} % => {(1cm,a,2cm,b)}

Users should note that support for default arguments referring to other arguments
is somewhat experimental. Feedback is therefore very welcome on the LaTeX-L mailing
list.

0.6 Default values for “embellishments”

The E-type argument allows one default value per test token. This is achieved by giving
a list of defaults for each entry in the list, for example:
E{^_}{{UP}{DOWN}}
If the list of default values is shorter than the list of test tokens, the special \NoValue
marker will be returned (as for the e-type argument). Thus for example
E{^_}{{UP}}
has default UP for the ^ test token, but will return the \NoValue marker as a default for
_. This allows mixing of explicit defaults with testing for missing values.

5
 0.7 Declaring commands and environments
With the concept of an argument specifier defined, it is now possible to describe the
methods available for creating both functions and environments using xparse.
The interface-building commands are the preferred method for creating document-
level functions in LATEX3. All of the functions generated in this way are naturally robust
(using the ε-TEX \protected mechanism).

\NewDocumentCommand \NewDocumentCommand hFunction i {harg spec i} {hcode i}

\RenewDocumentCommand
This family of commands are used to create a document-level hfunctioni. The argument
\ProvideDocumentCommand
\DeclareDocumentCommand specification for the function is given by harg speci, and expanding to be replaced by the
hcodei.
As an example:
\NewDocumentCommand \chapter { s o m }
{
\IfBooleanTF {#1}
{ \typesetstarchapter {#3} }
{ \typesetnormalchapter {#2} {#3} }
}
would be a way to define a \chapter command which would essentially behave like the
current LATEX 2ε command (except that it would accept an optional argument even when
a * was parsed). The \typesetnormalchapter could test its first argument for being
-NoValue- to see if an optional argument was present.
The difference between the \New... \Renew..., \Provide... and \Declare...
versions is the behaviour if hfunctioni is already defined.

• \NewDocumentCommand will issue an error if hfunctioni has already been defined.

• \RenewDocumentCommand will issue an error if hfunctioni has not previously been
defined.
• \ProvideDocumentCommand creates a new definition for hfunctioni only if one has
not already been given.
• \DeclareDocumentCommand will always create the new definition, irrespective of
any existing hfunctioni with the same name. This should be used sparingly.

TEXhackers note: Unlike LATEX 2ε ’s \newcommand and relatives, the \NewDocumentCommand

family of functions do not prevent creation of functions with names starting \end....

\NewDocumentEnvironment \NewDocumentEnvironment {henvironment i} {harg spec i}

\RenewDocumentEnvironment {hstart code i} {hend code i}
\ProvideDocumentEnvironment
\DeclareDocumentEnvironment

These commands work in the same way as \NewDocumentCommand, etc., but create en-
vironments (\begin{henvironmenti} . . . \end{henvironmenti}). Both the hstart codei
and hend codei may access the arguments as defined by harg speci. The arguments will
be given following \begin{henvironmenti}.

6
 0.8 Testing special values
Optional arguments created using xparse make use of dedicated variables to return infor-
mation about the nature of the argument received.

\IfNoValueT ? \IfNoValueTF {hargument i} {htrue code i} {hfalse code i}

\IfNoValueF ? \IfNoValueT {hargument i} {htrue code i}
\IfNoValueTF ? \IfNoValueF {hargument i} {hfalse code i}
The \IfNoValue(TF) tests are used to check if hargumenti (#1, #2, etc.) is the special
-NoValue- marker For example
\NewDocumentCommand \foo { o m }
{
\IfNoValueTF {#1}
{ \DoSomethingJustWithMandatoryArgument {#2} }
{ \DoSomethingWithBothArguments {#1} {#2} }
}
will use a different internal function if the optional argument is given than if it is not
present.
Note that three tests are available, depending on which outcome branches are re-
quired: \IfNoValueTF, \IfNoValueT and \IfNoValueF.
As the \IfNoValue(TF) tests are expandable, it is possible to test these values later,
for example at the point of typesetting or in an expansion context.
It is important to note that -NoValue- is constructed such that it will not match
the simple text input -NoValue-, i.e. that

\IfNoValueTF{-NoValue-}
will be logically false.
When two optional arguments follow each other (a syntax we typically discourage),
it can make sense to allow users of the command to specify only the second argument by
providing an empty first argument. Rather than testing separately for emptyness and for
-NoValue- it is then best to use the argument type O with an empty default value, and
simply test for emptyness using the expl3 conditional \tl_if_blank:nTF or its etoolbox
analogue \ifblank.

\IfValueT ? \IfValueTF {hargument i} {htrue code i} {hfalse code i}

\IfValueF ?
The reverse form of the \IfNoValue(TF) tests are also available as \IfValue(TF). The
\IfValueTF ?
context will determine which logical form makes the most sense for a given code scenario.

\BooleanFalse The true and false flags set when searching for an optional token (using s or thtoken i)
\BooleanTrue have names which are accessible outside of code blocks.

7
 \IfBooleanT ? \IfBooleanTF hargument i {htrue code i} {hfalse code i}
\IfBooleanF ?
Used to test if hargumenti (#1, #2, etc.) is \BooleanTrue or \BooleanFalse. For example
\IfBooleanTF ?
\NewDocumentCommand \foo { s m }
{
\IfBooleanTF #1
{ \DoSomethingWithStar {#2} }
{ \DoSomethingWithoutStar {#2} }
}

checks for a star as the first argument, then chooses the action to take based on this
information.

0.9 Argument processors

xparse introduces the idea of an argument processor, which is applied to an argument
after it has been grabbed by the underlying system but before it is passed to hcodei. An
argument processor can therefore be used to regularise input at an early stage, allowing
the internal functions to be completely independent of input form. Processors are applied
to user input and to default values for optional arguments, but not to the special \NoValue
marker.
Each argument processor is specified by the syntax >{hprocessori} in the argument
specification. Processors are applied from right to left, so that
>{\ProcessorB} >{\ProcessorA} m
would apply \ProcessorA followed by \ProcessorB to the tokens grabbed by the m
argument.

\ProcessedArgument xparse defines a very small set of processor functions. In the main, it is anticipated that
code writers will want to create their own processors. These need to accept one argument,
which is the tokens as grabbed (or as returned by a previous processor function). Proces-
sor functions should return the processed argument as the variable \ProcessedArgument.

\ReverseBoolean \ReverseBoolean
This processor reverses the logic of \BooleanTrue and \BooleanFalse, so that the ex-
ample from earlier would become
\NewDocumentCommand \foo { > { \ReverseBoolean } s m }
{
\IfBooleanTF #1
{ \DoSomethingWithoutStar {#2} }
{ \DoSomethingWithStar {#2} }
}

8
\SplitArgument \SplitArgument {hnumber i} {htoken i}
Updated: 2012-02-12 This processor splits the argument given at each occurrence of the htokeni up to a max-
imum of hnumberi tokens (thus dividing the input into hnumberi + 1 parts). An error
is given if too many htokensi are present in the input. The processed input is placed
inside hnumberi + 1 sets of braces for further use. If there are fewer than {hnumberi} of
{htokensi} in the argument then \NoValue markers are added at the end of the processed
argument.
\NewDocumentCommand \foo
{ > { \SplitArgument { 2 } { ; } } m }
{ \InternalFunctionOfThreeArguments #1 }
Any category code 13 (active) htokensi will be replaced before the split takes place.
Spaces are trimmed at each end of each item parsed.

\SplitList \SplitList {htoken(s) i}

This processor splits the argument given at each occurrence of the htoken(s)i where the
number of items is not fixed. Each item is then wrapped in braces within #1. The result
is that the processed argument can be further processed using a mapping function.
\NewDocumentCommand \foo
{ > { \SplitList { ; } } m }
{ \MappingFunction #1 }
If only a single htokeni is used for the split, any category code 13 (active) htokeni will be
replaced before the split takes place.

\ProcessList ? \ProcessList {hlist i} {hfunction i}

To support \SplitList, the function \ProcessList is available to apply a hfunctioni to
every entry in a hlisti. The hfunctioni should absorb one argument: the list entry. For
example
\NewDocumentCommand \foo
{ > { \SplitList { ; } } m }
{ \ProcessList {#1} { \SomeDocumentFunction } }
This function is experimental.

9
\TrimSpaces \TrimSpaces
Removes any leading and trailing spaces (tokens with character code 32 and category
code 10) for the ends of the argument. Thus for example declaring a function

\NewDocumentCommand \foo
{ > { \TrimSpaces } m }
{ \showtokens {#1} }
and using it in a document as
\foo{ hello world }

will show hello world at the terminal, with the space at each end removed. \TrimSpaces
will remove multiple spaces from the ends of the input in cases where these have been
included such that the standard TEX conversion of multiple spaces to a single space does
not apply.
This function is experimental.

0.10 Fully-expandable document commands

There are very rare occasion when it may be useful to create functions using a fully-
expandable argument grabber. To support this, xparse can create expandable functions
as well as the usual robust ones. This imposes a number of restrictions on the nature of
the arguments accepted by a function, and the code it implements. This facility should
only be used when absolutely necessary; if you do not understand when this might be, do
not use these functions!

10
\NewExpandableDocumentCommand \NewExpandableDocumentCommand
\RenewExpandableDocumentCommand hfunction i {harg spec i} {hcode i}
\ProvideExpandableDocumentCommand
\DeclareExpandableDocumentCommand

This family of commands is used to create a document-level hfunctioni, which will grab
its arguments in a fully-expandable manner. The argument specification for the function
is given by harg speci, and the function will execute hcodei. In general, hcodei will also
be fully expandable, although it is possible that this will not be the case (for example,
a function for use in a table might expand so that \omit is the first non-expandable
non-space token).
Parsing arguments expandably imposes a number of restrictions on both the type of
arguments that can be read and the error checking available:
• The last argument (if any are present) must be one of the mandatory types m or r.
• All short arguments appear before long arguments.

• The mandatory argument types l and u may not be used after optional arguments.
• The optional argument types g and G are not available.
• The “verbatim” argument type v is not available.

• Argument processors (using >) are not available.

• It is not possible to differentiate between, for example \foo[ and \foo{[}: in both
cases the [ will be interpreted as the start of an optional argument. As a result,
checking for optional arguments is less robust than in the standard version.
xparse will issue an error if an argument specifier is given which does not conform to
the first six requirements. The last item is an issue when the function is used, and so is
beyond the scope of xparse itself.

0.11 Access to the argument specification

The argument specifications for document commands and environments are available for
examination and use.

\GetDocumentCommandArgSpec \GetDocumentCommandArgSpec hfunction i

\GetDocumentEnvironmentArgSpec \GetDocumentEnvironmentArgSpec henvironment i

These functions transfer the current argument specification for the requested hfunctioni or
henvironmenti into the token list variable \ArgumentSpecification. If the hfunctioni
or henvironmenti has no known argument specification then an error is issued. The
assignment to \ArgumentSpecification is local to the current TEX group.

\ShowDocumentCommandArgSpec \ShowDocumentCommandArgSpec hfunction i

\ShowDocumentEnvironmentArgSpec \ShowDocumentEnvironmentArgSpec henvironment i

These functions show the current argument specification for the requested hfunctioni or
henvironmenti at the terminal. If the hfunctioni or henvironmenti has no known argument
specification then an error is issued.

11
 1 Load-time options
log-declarations The package recognises the load-time option log-declarations, which is a key–value
option taking the value true and false. By default, the option is set to true, meaning
that each command or environment declared is logged. By loading xparse using

\usepackage[log-declarations=false]{xparse}
this may be suppressed and no information messages are produced.

Index
The italic numbers denote the pages where the corresponding entry is described, numbers
underlined point to the definition, all others indicate the places where it is used.

Symbols \long . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
\\ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
N
A \New... . . . . . . . . . . . . . . . . . . . . . . . . . 6
\ArgumentSpecification . . . . . . . . 11, 11 \newcommand . . . . . . . . . . . . . . . . . . 1, 4, 6
\NewDocumentCommand . . . . . . 1, 6, 6, 6, 6, 6
B \NewDocumentEnvironment . . . . . . . 1, 6, 6
\begin . . . . . . . . . . . . . . . . . . . . . . . . 6, 6 \NewExpandableDocumentCommand 1, 11, 11
\BooleanFalse . . . . . . . . . . . . 3, 3, 7, 8, 8 \NoValue . . . . . . . . . . . . . . . . . . 5, 5, 8, 9
\BooleanTrue . . . . . . . . . . . . . 3, 3, 7, 8, 8
O
C \omit . . . . . . . . . . . . . . . . . . . . . . . . . . 11
\chapter . . . . . . . . . . . . . . . . . . . . . . . . 6 options:
log-declarations . . . . . . . . . . . . . . 12
D
\Declare... . . . . . . . . . . . . . . . . . . . ... 6 P
\DeclareDocumentCommand . . . . . . . 1, 6, 6 \ProcessedArgument . . . . . . . . . . . . . . 8, 8
\DeclareDocumentEnvironment . . . . . . 1, 6 \ProcessList . . . . . . . . . . . . . . . . . 9, 9, 9
\DeclareExpandableDocumentCommand 1, 11 \ProcessorA . . . . . . . . . . . . . . . . . . . ... 8
\ProcessorB . . . . . . . . . . . . . . . . . . . ... 8
E \protected . . . . . . . . . . . . . . . . . . . ... 6
\end . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 \Provide... . . . . . . . . . . . . . . . . . . . ... 6
\end... . . . . . . . . . . . . . . . . . . . . . . . . . 6 \ProvideDocumentCommand . . . . . . . 1, 6, 6
\ProvideDocumentEnvironment . . . . . . 1, 6
G \ProvideExpandableDocumentCommand 1, 11
\GetDocumentCommandArgSpec . . . . . 11, 11
\GetDocumentEnvironmentArgSpec . 11, 11 R
\Renew... . . . . . . . . . . . . . . . . . . . .... 6
I \RenewDocumentCommand . . . . . . . . . 1, 6, 6
\IfBoolean(TF) . . . .. . . . ........ ... 1 \RenewDocumentEnvironment . . . . . . . . 1, 6
\IfBooleanTF . . . . . .. . . . ........ . 8, 8 \RenewExpandableDocumentCommand . . 1, 11
\IfNoValue(TF) . . . .. . . . . . . . . 1, 7, 7, 7 \ReverseBoolean . . . . . . . . . . . . . . . . 8, 8
\IfNoValueTF . . . . . .. . . . 7, 7, 7, 7, 7, 7, 7
\IfValue(TF) . . . . . .. . . . ........ . 1, 7 S
\IfValueTF . . . . . . .. . . . ........ . 7, 7 \ShowDocumentCommandArgSpec . . . . 11, 11
\ShowDocumentEnvironmentArgSpec . 11, 11
L \SplitArgument . . . . . . . . . . . . . . . . . 9, 9
log-declarations (option) . . . . . . . . . . 12 \SplitList . . . . . . . . . . . . . . . . . . 9, 9, 9

12
 T \TrimSpaces . . . . . . . . . . . . . . . . 10, 10, 10
TEX and LATEX 2ε commands: \typesetnormalchapter . . . . . . . . . . . . . 6
\ifblank . . . . . . . . . . . . . . . . . . . . . 7
tl commands: V
\tl_if_blank:nTF . . . . . . . . . . . . . . . 7 \verb . . . . . . . . . . . . . . . . . . . . . . . . . 2, 5

13