1. Sentence-Case[link]

There are two sentence-case commands provided: \MFUsentencecase and \makefirstuc. A summary of the principle features of the two commands is given in Table 1.1.

1.1. Examples[link]

Text only (leading UTF-8 now supported):

\makefirstuc{élite} /
\MFUsentencecase{élite}

Leading punctuation is ignored:

\makefirstuc{`word'} /
\MFUsentencecase{`word'}

However, if the punctuation character is followed by a blocker or mapping command, the punctuation will need to be excluded otherwise the command will be treated as an exclusion. If possible, use semantic markup instead of directly including the punctuation.

Fragile commands need to be protected with \MFUsentencecase:

🖹
\newcommand{\alert}[1]{\textcolor{red}{\textbf{#1}}}
\makefirstuc{\alert{élite}} /
\MFUsentencecase{\protect\alert{élite}}

Exclusions are supported by both \makefirstuc and \MFUsentencecase:

🖹
\MFUexcl{\index}
\makefirstuc{\index{word}example} /
\MFUsentencecase{\index{word}example}

Blockers are only supported by \makefirstuc. They are treated as exclusions with \MFUsentencecase, which produces a different result:

🖹
\MFUblocker{\nameref}
\makefirstuc{\nameref{sec:sentencecase} section} /
\MFUsentencecase{\nameref{sec:sentencecase} section}

Mappings are only supported by \makefirstuc. They are treated as exclusions with \MFUsentencecase, which produces a different result:

🖹
\newrobustcmd{\secref}[1]{section~\ref{#1}}
\newrobustcmd{\Secref}[1]{Section~\ref{#1}}
\MFUaddmap{\secref}{\Secref}
\makefirstuc{\secref{sec:sentencecase} example} /
\MFUsentencecase{\secref{sec:sentencecase} example}

Argument expansion: \MFUsentencecase expands its argument and then skips exclusions whereas \makefirstuc parses its argument without expansion and then passes the relevant content to \glsmakefirstuc. Note that different results will occur with the expanded and unexpanded package options. For example:

🖹
\usepackage[expanded]{mfirstuc}
\newcommand{\testa}{sample}
\newcommand{\testb}{\testa\ test}
\begin{document}
\makefirstuc{\testb} / \xmakefirstuc{\testb} /
\emakefirstuc{\testb} / \MFUsentencecase{\testb}
\end{document}

🖹
\usepackage{mfirstuc}[=v2.07]
\newcommand{\testa}{sample}
\newcommand{\testb}{\testa\ test}
\begin{document}
\makefirstuc{\testb} / \xmakefirstuc{\testb} /
\emakefirstuc{\testb}
\end{document}

Argument expansion with mappings (and the default unexpanded option):

🖹
\newrobustcmd{\secref}[1]{section~\ref{#1}}
\newrobustcmd{\Secref}[1]{Section~\ref{#1}}
\MFUaddmap{\secref}{\Secref}
\newcommand{\testa}{\secref{sec:sentencecase}}
\newcommand{\testb}{\testa\ example}
\makefirstuc{\testb} / \xmakefirstuc{\testb} /
\emakefirstuc{\testb} / \MFUsentencecase{\testb}

1.2. Sentence Case Commands[link]

🖹
\newrobustcmd{\alert}[1]{\textcolor{red}{\textbf{#1}}}
\MFUsentencecase{\alert{sample} text}

🖹🛇
\newcommand{\alert}[1]{\textcolor{red}{\textbf{#1}}}
\MFUsentencecase{\alert{sample} text}

🖹🛇
\textcolor{Red}{\textbf{sample}} text

As from v2.08, the definition of \makefirstuc has been updated to use LaTeX3 code, but the argument is still parsed, which allows for non-robust semantic commands, and now also takes blockers and mappings into account. For example:

🖹
\newcommand{\alert}[1]{\textcolor{red}{\textbf{#1}}}
\makefirstuc{\alert{sample} text}

The rules used when parsing \makefirstuc{〈text〉} are as follows:

1. 1.if 〈text〉 is empty do nothing;

2. 2.if 〈text〉 consists of a single item or starts with a group do \glsmakefirstuc{〈text〉};

3. 3.if 〈text〉 starts with a command 〈cs〉:
   1. (a)if 〈cs〉 is \protect, skip it and continue to the next step where the command 〈cs〉 under inspection is now the one that follows \protect:

   2. (b)if 〈cs〉 has been identified as a blocker, just do 〈text〉 (that is, no case-change is applied);

   3. (c)if 〈cs〉 isn’t followed by a group then do \glsmakefirstuc{〈text〉};

   4. (d)otherwise assume the format is 〈cs〉{〈arg〉}〈following〉 (where 〈following〉 may be empty) and then:
      1. i.if 〈cs〉 has been mapped to 〈Cs〉 then do 〈Cs〉{〈arg〉}〈following〉;

      2. ii.if 〈cs〉 has been identified as an exclusion, do 〈cs〉{〈arg〉}\makefirstuc{〈following〉};

      3. iii.otherwise do 〈cs〉{\makefirstuc{〈arg〉}}〈following〉.

4. 4.otherwise do \glsmakefirstuc{〈text〉}.

Note that the above algorithm uses recursion. The termination points are: don’t implement a change, replace a command with another command, or apply the case-change via \glsmakefirstuc.

For convenience, the following commands are also provided:

\expandafter\makefirstuc\expandafter{〈text〉}

🖹
\newcommand{\test}[1]{sample #1}
\newcommand{\tmp}{\test{text}}
\makefirstuc{\tmp} /
\xmakefirstuc{\tmp} /
\emakefirstuc{\tmp}

\MFUsentencecase{\unexpanded{〈text〉}}

The expanded package option will redefine \glsmakefirstuc to use \MFUsentencecase without \unexpanded. The grabfirst package option will redefine \glsmakefirstuc to use \mfugrabfirstuc to emulates the behaviour of \glsmakefirstuc in v2.07 and below without using rollback.

This applies \mfirstucMakeUppercase to the first token in 〈text〉 and leaves the remainder unchanged. This won’t work if 〈text〉 starts with a UTF-8 character unless you use XeLaTeX or LuaLaTeX, so avoid using this method where possible. For example:

🖹
\renewcommand{\mfirstucMakeUppercase}[1]{% 
  \MakeUppercase{#1}% 
}
\mfugrabfirstuc{sample}

🖹
\mfirstucMakeUppercase{s}ample

🗋U
\renewcommand{\mfirstucMakeUppercase}[1]{% 
  \MakeUppercase{#1}% 
}
\mfugrabfirstuc{élite}

For example:

🖹
\mfugrabfirstuc{`sample'}

\mfirstucMakeUppercase{`}sample'

1.3. Exclusions[link]

Internally, \MFUexcl adds 〈cs〉 to LaTeX3’s exclusion list \l_text_case_exclude_arg_tl, which means that \MFUsentencecase will skip the command and its argument and apply the case-change to the following content. Some common commands (\begin \cite \end \label and \ref) are automatically added by the LaTeX3 kernel. The exclusions are also recognised by \makefirstuc when it parses its argument.

Another way of identifying content that should be excluded with \makefirstuc is to encapsulate it with:

The command name stems from earlier versions where leading punctuation needed to be skipped. This is no longer necessary, but the command remains as a general purpose robust exclusion command.

For example, \glsadd (provided by glossaries) should have its argument skipped, since its argument is a label, so the following will ensure that \glsadd{〈label〉} will be skipped, and the case-change will be applied to the following text for both \MFUsentencecase and \makefirstuc.

🖹
\MFUexcl{\glsadd}
\makefirstuc{\glsadd{ex}some text}
\MFUsentencecase{\glsadd{ex}some text}

\glsadd{ex}Some text

🖹🛇
\MFUexcl{\glsadd}
\makefirstuc{\glsadd[counter=section]{ex}some text}
\MFUsentencecase{\glsadd[counter=section]{ex}some text}

🔎
! Package glossaries Error: Glossary entry `[' has not been defined.

\glsadd{[}Counter=section] exsome text
\glsadd{[}Counter=section] exsome text

For this situation to work, you need to encapsulate the problematic content with an exclusion command, such as \NoCaseChange or \MFUskippunc:

🖹
\makefirstuc{\MFUskippunc{\glsadd[counter=section]{ex}}some text}

Punctuation characters are skipped by \MFUsentencecase. For example:

\MFUsentencecase{`word'}

However, leading punctuation will result in \makefirstuc passing its entire argument to \MFUsentencecase (since the argument doesn’t start with 〈cs〉{〈arg〉}), which means that \makefirstuc won’t detect any blocker or mapping.

For example:

🖹
\MFUblocker{\nameref}
\newcommand*{\qt}[1]{``#1''}
\makefirstuc{``\nameref{sec:sentencecase} section''} /
\makefirstuc{\MFUskippunc{``}\nameref{sec:sentencecase} section''} /
\makefirstuc{\qt{\nameref{sec:sentencecase} section}}

1.4. Blockers[link]

A blocker is a command that prevents any case-change if it occurs at the start of \makefirstuc or after the argument of an exclusion. Blockers are not supported by \MFUsentencecase but are instead treated as exclusions.

For example:

🖹
\MFUblocker{\nameref}
\makefirstuc{\nameref{sec:sentencecase} section} 

In the following, the blocker isn’t detected by \makefirstuc because the content doesn’t start with 〈cs〉{〈arg〉} or \protect〈cs〉{〈arg〉}. This means that the entire content is passed to \MFUsentencecase which treats \nameref as an exclusion:

🖹
\MFUblocker{\nameref}
\makefirstuc{\relax\nameref{sec:sentencecase} section} 

Recent LaTeX kernels provide \NoCaseChange and automatically add it as an exclusion. You may want to add it as a blocker for \makefirstuc. For example:

🖹
\makefirstuc{\ensuremath{\alpha}-particle} /
\makefirstuc{$\alpha$-particle} /
\MFUsentencecase{\ensuremath{\alpha}-particle} /
\MFUsentencecase{$\alpha$-particle}

\MFUblocker{\NoCaseChange}% 
\makefirstuc{\ensuremath{\alpha}-particle} /
\makefirstuc{\NoCaseChange{$\alpha$}-particle} /
\MFUsentencecase{\ensuremath{\alpha}-particle} /
\MFUsentencecase{\NoCaseChange{$\alpha$}-particle}

1.5. Mappings[link]

A mapping indicates that one command should be substituted for another, instead of applying a case-change. The assumption is that the substituted command should perform the case-change instead. Mappings are not supported by \MFUsentencecase but are instead treated as exclusions.

\MFUexcl{〈cs1〉}\MFUblocker{〈cs2〉}

For example (with glossaries):

🖹
\MFUaddmap{\gls}{\Gls}
\makefirstuc{\gls{ex} some text}

\Gls{ex} some text

1.6. Package Options[link]

This option is best avoided and is only provided to emulate the v2.07 behaviour of \glsmakefirstuc. However, you may still have different results compared to v2.07, so you may need to use rollback instead.

2. Title-Case[link]

The title-case commands are designed to convert the first letter of each word in a phrase to uppercase. These commands are robust.

\capitalisewords{a sample phrase}

See §2.1 for excluding words (such as “of”) from the case-changing.

For convenience, there are shortcut commands if expansion is required before parsing the argument:

\expandafter\capitalisewords\expandafter{〈text〉}

The parser used by \capitalisewords first splits up the text on each space character. Each of these space-separated words may actually be a compound, so further parsing is performed on each “word”. The divisions within the compound word should be marked up with:

\capitalisewords{a 
big\MFUwordbreak{/}small idea}

Each sub-word within the compound word is encapsulated with:

The conditional can be set to true with:

For example:

🖹
\capitalisewords{server-side includes} /
\MFUhyphentrue
\capitalisewords{server-side includes}

The actual case-change of each word is performed with:

Formatting for the entire phrase must go outside \capitalisewords (unlike \makefirstuc). For example:

🖹
\capitalisewords{\emph{a sample phrase}} /
\emph{\capitalisewords{a sample phrase}}

If your phrase is likely to contain formatting commands, you can instead use:

\capitalisefmtwords{〈words〉}

\capitalisefmtwords{〈cs〉{〈words〉}}

\capitalisefmtwords{〈words〉 〈cs〉{〈sub-phrase〉} 〈words〉}

If expansion is required, you can use:

\expandafter\capitalisefmtwords\expandafter{〈text〉}

2.1. Excluding Words From Case-Changing[link]

Some words typically shouldn’t have their case changed unless they occur at the start. These words can be identified with:

For example:

🖹
\capitalisewords{the wind in the willows}

\MFUnocap{in}% 
\MFUnocap{the}% 

\capitalisewords{the wind in the willows}

Since the case-change is ultimately performed by \makefirstuc, you can also use an exclusion to prevent an individual word from being changed. For example:

🖹
\newcommand{\NoChange}[1]{#1}
\MFUexcl{\NoChange}
\MFUclear
\capitalisewords{the \NoChange{wind} in the willows}

Examples:

1. 1.Exceptions aren’t applied if \MFUwordbreak occurs before the first space.

   🖹
   \MFUnocap{a}\MFUnocap{the}% 
   \capitalisewords{a\MFUwordbreak{/}the something}
   

   🖺

   A/The Something

2. 2.Exceptions are applied for non-leading words:

   🖹
   \MFUnocap{and}\MFUnocap{or}% 
   \capitalisewords{one and\MFUwordbreak{/}or another}
   

   🖺

   One and/or Another

3. 3.Exceptions aren’t applied for hyphenated parts:

   🖹
   \MFUhyphentrue
   \MFUnocap{and}\MFUnocap{or}% 
   \capitalisewords{one and-or another}
   

   🖺

   One And-Or Another

If you want to write a similar package for another language, all you need to do is create a file with the extension .sty that starts with:

\NeedsTeXFormat{LaTeX2e}

\ProvidesPackage{mfirstuc-french}

\ProvidesPackage{mfirstuc-french}[2014/07/30 v1.0]

\RequirePackage{mfirstuc}

\MFUnocap{de}

\endinput

Put the file somewhere on TeX’s path, and now you can use this package in your document. You might also consider uploading it to CTAN in case other users find it useful.

2.2. PDF Bookmarks[link]

If you are using hyperref and want to use \capitalisewords or \capitalisefmtwords (or the expanded variants) in a section heading, the PDF bookmarks won’t be able to use the command as it’s not expandable, so you will get a warning that looks like:

🔎
Package hyperref Warning: Token not allowed in a PDF string 
(PDFDocEncoding):
(hyperref)                removing `\capitalisewords'

If you want to provide an alternative for the PDF bookmark, you can use hyperref’s \texorpdfstring command. For example:

🖹
\chapter{\texorpdfstring
  {\capitalisewords{a book of rhyme}}%  TeX
  {A Book of Rhyme}%  PDF
}

🖹
\pdfstringdefDisableCommands{% 
 \let\capitalisewords\@firstofone
}

🖹
\pdfstringdefDisableCommands{% 
 \let\capitalisewords\MFUsentencecase
 \let\makefirstuc\MFUsentencecase
}

See the hyperref manual for further details.

2.3. Examples[link]

1. 1.Text only:
   🖹🖺

   \capitalisewords{a little book of rhyme}
   

   A Little Book Of Rhyme

2. 2.Excluding words (see §2.1):
   🖹🖺

   \MFUnocap{of}
   \capitalisewords{a little book of rhyme}
   

   A Little Book of Rhyme

3. 3.\space isn’t recognised as a word boundary:

   🖹
   \capitalisewords{a book of rhyme.}
   
   \capitalisewords{a book\space of rhyme.}
   

   🖺

   A Book Of Rhyme.

   A Book of Rhyme.

4. 4.Phrase entirely enclosed in a formatting command:

   🖹
   \capitalisefmtwords{\emph{a small book of rhyme}}
   

   🖺

   A Small Book Of Rhyme

5. 5.Sub-phrase enclosed in a formatting command:

   🖹
   \capitalisefmtwords{a \emph{small book} of rhyme}
   

   🖺

   A Small Book Of Rhyme

6. 6.Nested text-block commands:

   🖹
   \capitalisefmtwords{\textbf{a \emph{small book}} of rhyme}
   

   🖺

   A Small Book Of Rhyme

7. 7.Formatting and case-change exception (see §2.1):

   🖹
   \MFUnocap{of}
   \capitalisefmtwords{\textbf{a \emph{small book}} of rhyme}
   

   🖺

   A Small Book of Rhyme

8. 8.Starred form:

   🖹
   \MFUnocap{of}
   \capitalisefmtwords*{\emph{a small book of rhyme}}
   

   🖺

   A Small Book of Rhyme

9. 9.The starred form also works with just text (no text-block command):

   🖹
   \MFUnocap{of}
   \capitalisefmtwords*{a small book of rhyme}
   

   🖺

   A Small Book of Rhyme

10. 10.Expansion:

    🖹
    \newcommand{\abc}{\xyz\space four five}
    \newcommand{\xyz}{one two three}
    No expansion: \capitalisewords{\abc}.
    
    First object one-level expansion: \xcapitalisewords{\abc}.
    
    Fully expanded: \ecapitalisewords{\abc}.
    

    🖺

    No expansion: one two three four five.

    First object one-level expansion: one two three Four Five.

    Fully expanded: One Two Three Four Five.

    Remember that the spaces need to be explicit. In the second case above, using \xcapitalisewords, the space before “four” has been hidden within \space so it’s not recognised as a word boundary, but in the third case, \space has been expanded to an actual space character.

If there is a text-block command within the argument of the starred form, it’s assumed to be at the start of the argument. Unexpected results can occur if there are other commands. For example:

🖹🛇
\MFUnocap{of}
\capitalisefmtwords*{\emph{a small} book \textbf{of rhyme}}

🖹🛇
\MFUnocap{of}
\capitalisefmtwords*{a \emph{very small} book of rhyme}

Grouping causes interference. As with all the commands described here, avoid declarations.

🖹🛇
\capitalisefmtwords{{\bfseries a \emph{small book}} of rhyme}

Avoid complicated commands in the unstarred version. For example, the following breaks:

🖹🛇
\newcommand*{\swap}[2]{{#2}{#1}}
\capitalisefmtwords{a \swap{bo}{ok} of rhyme}

🖹
\newcommand*{\swap}[2]{{#2}{#1}}
\capitalisefmtwords*{a \swap{bo}{ok} of rhyme}

\capitalisewords{a \swap{bo}{ok} of rhyme}

3. Miscellaneous[link]

3.1. Saving exclusions, blockers and mappings in the aux File[link]

If the exclusions, mappings and blockers are required by some external tool, the information can be saved in the aux file.

The associated aux commands are listed below. In each case, a definition is provided in the aux file that does nothing.

\@mfu@excls{\begin \cite \end \label
\ref \cite \NoCaseChange \ensuremath
\MFUskippunc \gls \glspl}

\@mfu@blockers{\Gls \Glspl }

\@mfu@mappings{ {\gls }= {\Gls }, {\glspl }= {\Glspl }}

3.2. All-Caps[link]

The textcase package has been deprecated as from 2022 and it now simply sets \MakeTextUppercase to \MakeUppercase because the new kernel now defines \MakeUppercase to use the newer LaTeX3 command \text_uppercase:n. Although that command is expandable, \MakeUppercase is robust.

As from v2.08, mfirstuc now defines \mfirstucMakeUppercase so that it uses \text_titlecase_first:n directly, rather than indirectly through \MakeUppercase, which means that it’s now expandable. However, \mfirstucMakeUppercase is no longer used by mfirstuc except in \mfugrabfirstuc, which is provided to emulate v2.07. Note that the grabfirst option will also redefine \mfirstucMakeUppercase to use \MakeUppercase.

3.3. UTF-8[link]

This section only applies to rollback or the use of \mfugrabfirstuc (implemented via the grabfirst option).

Prior to version 2.08, the case-change applied by the \glsmakefirstuc command worked by utilizing the fact that, in most cases, TeX doesn’t require a regular argument to be enclosed in braces if it only consists of a single token. (This is why you can do, say, \frac12 instead of \frac{1}{2} or x^2 instead of x^{2}, although this practice is discouraged by some.)

A simplistic version of the original \glsmakefirstuc command is:

🖹
\newcommand*{\FirstUC}[1]{\MakeUppercase #1}

🖹
\FirstUC{abc}

🖹
\MakeUppercase abc

Unfortunately, this will fail if the content starts with a UTF-8 character and you are using pdfLaTeX, where each octet of the UTF-8 character is a separate token. This isn’t a problem with XeLaTeX and LuaLaTeX which both treat the entire multibyte character as a single token.

LaTeX3 now provides \text_titlecase_first:n to convert the first character to uppercase, so now the case-change can be applied with:

🖹
\ExplSyntaxOn
\text_titlecase_first:n{élite}
\ExplSyntaxOff

Symbols[link]

📌

The syntax and usage of a command, environment or option etc.

ℹ

An important message.

🛈

Prominent information.

🖹

LaTeX code to insert into your document.

🖹🛇

Problematic code which should be avoided.

🖺

How the example code should appear in the PDF.

🔎

Text in a transcript or log file or written to STDOUT or STDERR.

🗋U

Code that requires a native Unicode engine (XeLaTeX or LuaLaTeX).

𝍢

An option that doesn’t take a value.

⚠

A warning.

Glossary[link]

Blocker

A command that prohibits case-changing. If encountered by \makefirstuc, it won’t attempt to apply any case-changing. See §1.4.

Exclusion command

A command whose argument should be skipped by the case-changer. The content that follows the command should have its case-changed instead. See §1.3.

Exclusion word

A word that shouldn’t have its case changed by title-case commands, unless the word occurs at the start.

Mapping

A command that should be substituted by another, if encountered by \makefirstuc, instead of applying a case-change. See §1.5.

Semantic command

Essentially, this is a command associated with a particular element, idea or topic that hides the font and other stylistic formatting inside its definition. For example, Latin taxonomy is usually displayed in italic. Explicitly using font commands, for example

\textit{Clostridium}

is syntactic markup. Whereas defining a command called, say, \bacteria that displays its argument in italics is a semantic command. The actual styling is hidden and the command relates specifically to a particular concept.

🖹
Syntactic: \textit{Clostridium}

\newrobustcmd*{\bacteria}[1]\emph{#1}%
Semantic: \bacteria{Clostridium} 

The end result is the same:

🖺

Syntactic: Clostridium

Semantic: Clostridium

The advantage with semantic commands is that it’s much easier to change the style, simply by adjusting the command definition. Note that I’ve used \newrobustcmd to make the semantic command robust as the style commands can cause a problem if they expand too soon.

Sentence-case

Content that should appear at the start of a sentence that needs to have its first significant character converted to uppercase. See §1.

Title-case

Content that needs to appear in a title that should have each significant word converted to sentence-case. See §2.

Unicode Transformation Format (8-bit) (UTF-8)

A variable-width encoding that uses 8-bit code units. This means that some characters are represented by more that one byte. XeLaTeX and LuaLaTeX treat the multi-byte sequence as a single token, but the older LaTeX formats have single-byte tokens, which can cause complications, although these have mostly been addressed with the newer kernels introduced over the past few years. Related blog article: Binary Files, Text Files and File Encodings.

Command Summary[link]

@[link]

An aux file command that lists all the identified blockers. §3.1; 24

An aux file command that lists all the identified exclusions. §3.1; 24

An aux file command that lists all the identified mappings as a 〈key〉=〈value〉 list. §3.1; 25

C[link]

Similar to \capitalisewords but for content that may contain formatting commands. §2; 15

Applies title-case to 〈text〉. This will apply \MFUcapword to each word in 〈text〉 (unless the word has been identified as an exclusion word and doesn’t occur at the start of 〈text〉). §2; 13

E[link]

Fully expands 〈text〉 and passes it to \capitalisefmtwords including the * modifier, if provided. §2; 16

Fully expands 〈text〉 before passing it to \capitalisewords. §2; 13

Fully expands 〈text〉 before passing it to \makefirstuc. §1.2; 5

G[link]

Used by \makefirstuc to perform the case-change. This uses \MFUsentencecase{〈text〉} but by default will prevent its argument from being expanded. §1.2; 6

Globally adds 〈word〉 to the exclusion word list for \capitalisewords. §2.1; 16

I[link]

Conditional that determines whether or not hyphens should be considered word boundaries by the title-case commands. §2; 14

M[link]

Converts 〈text〉 to sentence-case internally using \glsmakefirstuc to perform the case-change, but first parses 〈text〉 to deal with special cases. §1.2; 4

Converts 〈text〉 to uppercase. Now only used in \mfugrabfirstuc. §3.2; 25

Identifies a mapping from the command 〈cs1〉 to command 〈cs2〉. §1.5; 11

Locally identifies 〈cs〉 as a blocker command. §1.4; 10

Uses either \MFUhyphencapword or \MFUcapwordfirstuc depending on \ifMFUhyphen. §2; 14

Used by \MFUcapword and \MFUhyphencapword to apply the case-change to the given word. This just does \makefirstuc{〈text〉} by default. §2; 14

Locally clears the exclusion word list for \capitalisewords. §2.1; 16

Locally identifies 〈cs〉 as an exclusion command. §1.3; 7

Provide to emulate \glsmakefirstuc in v2.07 and below, but can still produce different results to v2.07. This will attempt to grab only the first character of 〈text〉 and convert it to uppercase, leaving the rest of 〈text〉 unchanged. This won’t work if 〈text〉 starts with a UTF-8 character, unless you are using XeLaTeX or LuaLaTeX. §1.2; 6

Used by \MFUcapword to apply \MFUcapwordfirstuc to each hyphen-separated word in 〈text〉, if hyphens should indicate a word-break. §2; 14

Sets \ifMFUhyphen to false. §2; 14

Sets \ifMFUhyphen to true. §2; 14

Locally adds 〈word〉 to the exclusion word list for \capitalisewords. §2.1; 16

Saves the list of exclusions, blockers and mappings to the aux file (if required by some external tool). This command sets itself to \relax so it doesn’t repeat the action if used multiple times, and counteracts any use of \MFUsaveatend. §3.1; 24

Saves the list of exclusions, blockers and mappings to the aux file (if required by some external tool) at the end of the document. This command sets itself to \relax so it doesn’t repeat the action if used multiple times, but it can be overridden by \MFUsave. §3.1; 24

Converts 〈text〉 to sentence-case with expansion. §1.2; 4

An exclusion command. §1.3; 8

Used to markup a character or command that should be treated as a word break by the title-case commands. §2; 13

X[link]

Shortcut for \expandafter\capitalisefmtwords\expandafter{〈text〉} including the * modifier, if provided. §2; 15

Shortcut for \expandafter\capitalisewords\expandafter{〈text〉}. §2; 13

Shortcut for \expandafter\makefirstuc\expandafter{〈text〉}. §1.2; 5

Index[link]

Symbols[link]

@[link]

B[link]

C[link]

E[link]

F[link]

G[link]

H[link]

I[link]

L[link]

M[link]

N[link]

P[link]

R[link]

S[link]

T[link]

U[link]

X[link]