diff options
Diffstat (limited to 'support/digestif/data/biblatex.sty.tags')
-rw-r--r-- | support/digestif/data/biblatex.sty.tags | 7982 |
1 files changed, 7982 insertions, 0 deletions
diff --git a/support/digestif/data/biblatex.sty.tags b/support/digestif/data/biblatex.sty.tags new file mode 100644 index 0000000000..a99a80fe65 --- /dev/null +++ b/support/digestif/data/biblatex.sty.tags @@ -0,0 +1,7982 @@ +-- Copyright 2006-2012 Philipp Lehman +-- Copyright 2012-2022 Philipp Lehman, Joseph Wright, Audrey Boruvka, +-- Philip Kime +-- Copyright 2022 Augusto Stoffel +-- SPDX-License-Identifier: LPPL-1.3c +-- +-- Adapted from the biblatex package documentation, which can be found +-- at https://github.com/plk/biblatex. +ctan_package = "biblatex" +dependencies = { + "blx-case-expl3.sty", + "blx-case-latex2e.sty", + "etexcmds.sty", + "etoolbox.sty", + "expl3.sty", + "iftex.sty", + "ifthen.sty", + "infwarerr.sty", + "keyval.sty", + "kvoptions-patch.sty", + "kvoptions.sty", + "kvsetkeys.sty", + "logreq.sty", + "ltxcmds.sty", + "pdftexcmds.sty", + "url.sty", + "xparse.sty" +} +commands = { + AtBeginBibliography = { + arguments = {{meta = "code"}}, + details = [[ +```latex +\AtBeginBibliography{code} +``` + +Appends the `code` to an internal hook executed at the beginning of the +bibliography. The `code` is executed at the beginning of the list of +references, immediately after the `begin code` of `\defbibenvironment`. +This command may only be used in the preamble. +]] + }, + AtBeginBiblist = { + arguments = {{meta = "biblistname"}, {meta = "code"}}, + details = [[ +```latex +\AtBeginBiblist{biblistname}{code} +``` + +Appends the `code` to an internal hook executed at the beginning of the +bibliography list `biblistname`. The `code` is executed at the beginning +of the bibliography list, immediately after the `begin code` of +`\defbibenvironment`. This command may only be used in the preamble. +]] + }, + AtEveryCitekey = { + arguments = {{meta = "code"}}, + details = [[ +```latex +\AtEveryCitekey{code} +``` + +Appends the `code` to an internal hook executed once for every entry key +passed to a citation command. The `code` is executed immediately before +the `loopcode` of the command (see ??). The bibliographic data of the +respective entry is available at this point. This command may only be +used in the preamble. +]] + }, + AtEveryEntrykey = { + arguments = {{meta = "code"}, {meta = "success"}, {meta = "failure"}}, + details = [[ +```latex +\AtEveryEntrykey{code}{success}{failure} +``` + +Appends `code` to an internal hook executed every time an entrykey is +processed for a citation command or `\nocite`. The `code` is passed one +argument (`#1`), which contains the entrykey. If the code can be +appended to the hook `success` is executed, otherwise `failure` is +executed. Unlike `\AtEveryCitekey` the entry data of the current +entrykey is not available when `code` is processed, indeed it is not +even known whether or not there is any entry data at all. +]] + }, + AtEveryLositem = { + arguments = {{meta = "code"}}, + details = [[ +```latex +\AtEveryLositem{code} +``` + +Appends the `code` to an internal hook executed at the beginning of +every item in the list of shorthands. The `code` is executed immediately +after the `item code` of `\defbibenvironment`. The bibliographic data of +the respective entry is available at this point. This command may only +be used in the preamble. + +This is just an alias for: + + \AtEveryBiblistitem{shorthand}{code} +]] + }, + AtNextBibliography = { + arguments = {{meta = "code"}}, + details = [[ +```latex +\AtNextBibliography{code} +``` + +Similar to `\AtBeginBibliography` but only affecting the next +`\printbibliography`. The internal hook is cleared after being executed +once. This command may be used in the document body. +]] + }, + AtNextCite = { + arguments = {{meta = "code"}}, + details = [[ +```latex +\AtNextCite{code} +``` + +Similar to `\AtEveryCite` but only affecting the next citation command. +The internal hook is cleared after being executed once. This command may +be used in the document body. +]] + }, + AtNextCitekey = { + arguments = {{meta = "code"}}, + details = [[ +```latex +\AtNextCitekey{code} +``` + +Similar to `\AtEveryCitekey` but only affecting the next entry key. The +internal hook is cleared after being executed once. This command may be +used in the document body. +]] + }, + AtUsedriver = { + arguments = {{literal = "*", optional = true}, {meta = "code"}}, + details = [[ +```latex +\AtUsedriver*{code} +``` + +Appends the `code` to an internal hook executed when initializing +`\usedriver`. The starred variant of the command clears the +initialisation hook, so the defaults can be overwritten. This command +may only be used in the preamble. The default setting is: + + \AtUsedriver{% + \delimcontext{bib}% + \let\finentry\blx@finentry@usedrv + \let\newblock\relax + \let\abx@macro@bibindex\@empty + \let\abx@macro@pageref\@empty} +]] + }, + AtVolcite = { + arguments = {{literal = "*", optional = true}, {meta = "code"}}, + details = [[ +```latex +\AtVolcite{code} +\AtVolcite*{code} +``` + +Appends the `code` to an internal hook executed when initializing +`\volcite`. The starred variant of the command clears the initialisation +hook, so the defaults can be overwritten. This command may only be used +in the preamble. The default setting is: + + \AtVolcite{% + \DeclareFieldAlias{postnote}{volcitenote}} +]] + }, + Autocite = { + action = "cite", + arguments = { + {literal = "*", optional = true}, + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\autocite[prenote][postnote]{key} +\Autocite[prenote][postnote]{key} +``` + +In contrast to other citation commands, the `\autocite` command does not +only scan ahead for punctuation marks following its last argument to +avoid double punctuation marks, it actually moves them around if +required. For example, with `autocite=footnote`, a trailing punctuation +mark will be moved such that the footnote mark is printed after the +punctuation. `\Autocite` is similar to `\autocite` but capitalizes the +name prefix of the first name in the citation if the `useprefix` option +is enabled, provided that there is a name prefix and the citation style +prints any name at all. + +```latex +\Autocite*[prenote][postnote]{key} +``` + +The starred variants of `\autocite` do not behave differently from the +regular ones. The asterisk is simply passed on to the backend command. +For example, if `\autocite` is configured to use `\parencite`, then +`\autocite*` will execute `\parencite*`. +]] + }, + Autocites = { + action = "cite", + details = [[ +```latex +\Autocites(multiprenote)(multipostnote)[prenote][postnote]{key}|...|[prenote][postnote]{key} +``` + +This is the multicite version of `\autocite`. It also detects and moves +punctuation if required. Note that there is no starred variant. +`\Autocites` is similar to `\autocites` but capitalizes the name prefix +of the first name in the citation if the `useprefix` option is enabled, +provided that there is a name prefix and the citation style prints any +name at all. +]] + }, + Avolcite = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {meta = "volume"}, + {delimiters = {"[", "]"}, meta = "pages", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\Avolcite[prenote]{volume}[pages]{key} +``` + +Similar to `\volcite` but based on `\autocite`. +]] + }, + Avolcites = { + action = "cite", + details = [[ +```latex +\Avolcites(multiprenote)(multipostnote)[prenote]{volume}[pages]{key}|\\...|[prenote]{volume}[pages]{key} +``` + +The multicite version of `\avolcite` and `\Avolcite`, respectively. +]] + }, + Cite = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\cite[prenote][postnote]{key} +\Cite[prenote][postnote]{key} +``` + +These are the bare citation commands. They print the citation without +any additions such as parentheses. The numeric and alphabetic styles +still wrap the label in square brackets since the reference may be +ambiguous otherwise. `\Cite` is similar to `\cite` but capitalizes the +name prefix of the first name in the citation if the `useprefix` option +is enabled, provided that there is a name prefix and the citation style +prints any name at all. +]] + }, + Citeauthor = { + action = "cite", + arguments = { + {literal = "*", optional = true}, + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\citeauthor[prenote][postnote]{key} +\citeauthor*[prenote][postnote]{key} +\Citeauthor[prenote][postnote]{key} +\Citeauthor*[prenote][postnote]{key} +``` + +These commands print the authors. Strictly speaking, it prints the +`labelname` list, which may be the `author`, the `editor`, or the +`translator`. `\Citeauthor` is similar to `\citeauthor` but capitalizes +the name prefix of the first name in the citation if the `useprefix` +option is enabled, provided that there is a name prefix. The starred +variants effectively force maxcitenames to 1 for just this command on so +only print the first name in the labelname list (potentially followed by +the «et al» string if there are more names). This allows more natural +textual flow when refering to a paper in the singular when otherwise +`\citeauthor` would generate a (naturally plural) list of names. +]] + }, + Cites = { + action = "cite", + details = [[ +```latex +\cites(multiprenote)(multipostnote)[prenote][postnote]{key}|...|[prenote][postnote]{key} +\Cites(multiprenote)(multipostnote)[prenote][postnote]{key}|...|[prenote][postnote]{key} +``` + +The multicite version of `\cite` and `\Cite`, respectively. +]] + }, + DeclareBabelToExplLanguageMapping = { + arguments = {{meta = "babel language"}, {meta = "expl language"}}, + details = [[ +```latex +\DeclareBabelToExplLanguageMapping{babel language}{expl language} +``` + +This command is only available if the `expl3` case changing code is +used. + +Use `expl language` as `language` argument for the `l3text` case +changing functions when `babel language` is active. This command is only +required if `babel language` should correspond to a language for which +`l3text` has special rules set up. The default invocations of this +command are + + \DeclareBabelToExplLanguageMapping{dutch}{nl} + \DeclareBabelToExplLanguageMapping{greek}{el} + \DeclareBabelToExplLanguageMapping{turkish}{tr} +]] + }, + DeclareBibliographyCategory = { + arguments = {{meta = "category"}}, + details = [[ +```latex +\DeclareBibliographyCategory{category} +``` + +Declares a new `category`, to be used in conjunction with +`\addtocategory` and the `category` and `notcategory` filters of +`\printbibliography`. This command is used in the document preamble. +]] + }, + DeclareBibliographyDriver = { + arguments = {{meta = "entrytype"}, {meta = "code"}}, + details = [[ +```latex +\DeclareBibliographyDriver{entrytype}{code} +``` + +Defines a bibliography driver. A <driver> is a macro which handles a +specific entry type (when printing bibliography lists) or a specific +named bibliography list (when printing bibliography lists). The +`entrytype` corresponds to the entry type used in `bib` files, specified +in lowercase letters (see ??). The `entrytype` argument may also be an +asterisk. In this case, the driver serves as a fallback which is used if +no specific driver for the entry type has been defined. The `code` is +arbitrary code which typesets all bibliography entries of the respective +`entrytype`. This command is mandatory. Every bibliography style should +provide a driver for each entry type. +]] + }, + DeclareBibliographyExtras = { + arguments = {{meta = "code"}}, + details = [[ +```latex +\DeclareBibliographyExtras{code} +``` + +This command is only available in `lbx` files. It is used to adapt +language specific features such as the date format and ordinals. The +`code`, which may be arbitrary LaTeX code, will usually consist of +redefinitions of the formatting commands from ??. +]] + }, + DeclareBibliographyOption = { + arguments = { + {delimiters = {"[", "]"}, meta = "datatype", optional = true}, + {meta = "key"}, + {delimiters = {"[", "]"}, meta = "value", optional = true}, + {meta = "code"} + }, + details = [[ +```latex +\DeclareBibliographyOption[datatype]{key}[value]{code} +``` +]] + }, + DeclareBibliographyStrings = { + arguments = {{meta = "definitions"}}, + details = [[ +```latex +\DeclareBibliographyStrings{definitions} +``` + +This command is only available in `lbx` files. It is used to define +localisation strings. The `definitions` consist of `key=value`pairs +which assign an expression to an identifier. A complete list of all keys +supported by default is given is ??. Note that the syntax of the value +is different in `lbx` files. The value assigned to a key consists of two +expressions, each of which is wrapped in an additional pair of brackets. +This is best shown by example: + + \DeclareBibliographyStrings{% + bibliography = {{Bibliography}{Bibliography}}, + shorthands = {{List of Abbreviations}{Abbreviations}}, + editor = {{editor}{ed.}}, + editors = {{editors}{eds.}}, + } + +The first value is the long, written out expression, the second one is +an abbreviated or short form. Both strings must always be given even +though they may be identical if an expression is always (or never) +abbreviated. Depending on the setting of the `abbreviate` package option +(see ??), `biblatex`selects one expression when loading the `lbx` file. +There is also a special key named `inherit` which copies the strings +from a different language. This is intended for languages which only +differ in a few expressions, such as German and Austrian or American and +British English. For example, here are the complete definitions for +Austrian: + + \DeclareBibliographyStrings{% + inherit = {german}, + january = {{J\"anner}{J\"an.}}, + } + +The above examples are slightly simplified. Real localisation files +should use the punctuation and formatting commands discussed in ?? +instead of literal punctuation. Here is an excerpt from a real +localisation file: + + bibliography = {{Bibliography}{Bibliography}}, + shorthands = {{List of Abbreviations}{Abbreviations}}, + editor = {{editor}{ed\adddot}}, + editors = {{editors}{eds\adddot}}, + byeditor = {{edited by}{ed\adddotspace by}}, + mathesis = {{Master's thesis}{MA\addabbrvspace thesis}}, + +Note the handling of abbreviation dots, the spacing in abbreviated +expressions, and the capitalization in the example above. All +expressions should be capitalized as they usually are when used in the +middle of a sentence. The `biblatex`package will automatically +capitalize the first word when required at the beginning of a sentence, +see `\DeclareCapitalPunctuation` in ?? for details. Expressions intended +for use in headings are special. They should be capitalized in a way +that is suitable for titling and should not be abbreviated (but they may +have a short form). +]] + }, + DeclareBiblistFilter = { + arguments = {{meta = "name"}, {meta = "specification"}}, + details = [[ +```latex +\DeclareBiblistFilter{name}{specification} +``` + +Defines a bibliography list filter with `name`. The `specification` +consists of one or more `\filter` or `\filteror` macros, all of which +must be satisfied for the entry to pass the filter: +]] + }, + DeclareBibstringSet = { + arguments = {{meta = "setname"}, {meta = "key, ... "}}, + details = [[ +```latex +\DeclareBibstringSet{setname}{key, ... } +``` + +This commands assigns all `key`s to the bibliography string set +`setname`. +]] + }, + DeclareCapitalPunctuation = { + arguments = {{meta = "characters"}}, + details = [[ +```latex +\DeclareCapitalPunctuation{characters} +``` + +When `biblatex`inserts localisation strings, i.e. key terms such as +<edition> or <volume>, it automatically capitalizes them after +terminal punctuation marks. This command defines the punctuation marks +which will cause localisation strings to be capitalized if one of them +precedes a string. Note that `characters` is an undelimited list of +characters. Valid `characters` are period, comma, semicolon, colon, +exclamation and question mark. The package default is: + + \DeclareCapitalPunctuation{.!?} + +Using `\DeclareCapitalPunctuation` with an empty argument is equivalent +to disabling automatic capitalization. Since this feature is language +specific, this command must be used in the argument to +`\DefineBibliographyExtras` (when used in the preamble) or +`\DeclareBibliographyExtras` (when used in a localisation module). See +?? for details. By default, strings are capitalized after periods, +exclamation marks, and question marks. All strings are generally +capitalized at the beginning of a paragraph (in fact whenever TeX is in +vertical mode). +]] + }, + DeclareCaseLangs = { + arguments = {{literal = "*", optional = true}, {meta = "languages"}}, + details = [[ +```latex +\DeclareCaseLangs{languages} +\DeclareCaseLangs*{languages} +``` + +Defines the list of languages which are considered by the +`\MakeSentenceCase*` command as it converts a string to sentence case. +The `languages` argument is a comma-separated list of +`babel`/`polyglossia` language identifiers. The regular version of this +command replaces the current setting, the starred version appends its +argument to the current list. The default setting is: + + \DeclareCaseLangs{% + american,british,canadian,english,australian,newzealand,USenglish,UKenglish} + +See the `babel`/`polyglossia` manuals and ?? for a list of languages +identifiers. +]] + }, + DeclareCitePunctuationPosition = { + arguments = {{meta = "command"}, {meta = "position"}}, + details = [[ +```latex +\DeclareCitePunctuationPosition{command}{position} +``` + +Set up the cite command `command` to move punctuation marks after the +citation like `\autocite`. The `position` argument can take the values +`r`, `l`, `f`, `c`, `o` and `d`. If an unknown `position` identifier is +used, it defaults to `o`. + +r +The punctuation mark is not moved and remains to the right of the +citation. + +l +The punctuation mark is moved to the left of the citation and thus +appears before it. + +f +Like `r` in footnotes and like `l` otherwise. + +c +Pass the punctuation on to the internal implementation of the citation +commands. It will then be executed within the `wrapper` command if +given. + +o +Retain the default setup of `c` for citation defined commands without +`wrapper` command and `l` for citation commands defined with a `wrapper` +command. + +d +Drop the explicit punctuation mark. It will only be available as the +field `postpunct`. + +This command can not be used for `\autocite`, to configure `\autocite` +use the optional `position` argument for `\DeclareAutoCiteCommand`. +]] + }, + DeclareDataInheritance = { + arguments = { + {delimiters = {"[", "]"}, meta = "options", optional = true}, + {meta = "source, ... "}, + {meta = "target, ... "}, + {meta = "rules"} + }, + details = [[ +```latex +\DeclareDataInheritance[options]{source, ... }{target, ... }{rules} +``` + +Declares inheritance rules. The `source` and `target` arguments specify +the parent and the child entry type. Either argument may be a single +entry type, a comma-separated list of types, or an asterisk. The +asterisk matches all entry types. The `rules` are an undelimited list of +`\inherit` and/or `\noinherit` directives. Spaces, tabs, and line +endings may be used freely to visually arrange the `rules`. Blank lines +are not permissible. This command may only be used in the preamble. The +options are: + +`ignore=<csv list of uniqueness options>` +As the `ignore` option on `\DefaultInheritance` explained above. When +set here, it takes precedence over any global options set with +`\DefaultInheritance`. For example, this would ignore `singletitle` and +`uniquetitle` tracking for a `book` inheriting from a `mvbook`. + + \DeclareDataInheritance[ignore={singletitle,uniquetitle}]{mvbook}{book}{<<...>>} +]] + }, + DeclareDatafieldSet = { + arguments = {{meta = "name"}, {meta = "specification"}}, + details = [[ +```latex +\DeclareDatafieldSet{name}{specification} +``` + +Declare a set of datasource fields with name `name`. + +`name=<set name>` +The name of the set. + +The `specification` is one or more `\member` items: +]] + }, + DeclareDatamodelConstant = { + arguments = { + {delimiters = {"[", "]"}, meta = "options", optional = true}, + {meta = "name"}, + {meta = "constantdef"} + }, + details = [[ +```latex +\DeclareDatamodelConstant[options]{name}{constantdef} +``` + +Declares the `name` as a datamodel constant with definition +`constantdef`. Such constants are typically used internally by `biber`. + +`type={string, list}` +A constant can be a simple string (default if the `type` option is +omitted) or a comma-separated list of strings. +]] + }, + DeclareDatamodelConstraints = { + arguments = { + {delimiters = {"[", "]"}, meta = "entrytypes", optional = true}, + {meta = "specification"} + }, + details = [[ +```latex +\DeclareDatamodelConstraints[entrytypes]{specification} +``` + +If a comma-separated list of `entrytypes` is given, the constraints +apply only to those entrytypes. The `specification` is an undelimited +list of `\constraint` directives which specify a constraint. Spaces, +tabs, and line endings may be used freely to visually arrange the +`specification`. Blank lines are not permissible. +]] + }, + DeclareDatamodelFields = { + arguments = { + {delimiters = {"[", "]"}, meta = "options", optional = true}, + {meta = "fields"} + }, + details = [[ +```latex +\DeclareDatamodelFields[options]{fields} +``` + +Declares the comma-separated list of `fields` to be valid fields in the +data model with associated comma-separated `options`. The `type` and +`datatype` options are mandatory. All valid `options` are: + +`type=<field type>` +Set the type of the field as described in ??, typically <field> or +<list>. + +`format=<field format>` +Any special format of the field. Normally unspecified but can take the +value <xsv> which tells `biber`that this field has a separated values +format. The exact separator can be controlled with the `biber`option +`xsvsep` and defaults to the expected comma surrounded by optional +whitespace. + +`datatype=<field datatype>` +Set the datatype of the field as described in ??. For example, <name> +or <literal>. + +`nullok` +The field is allowed to be defined but empty. + +`skipout` +The field is not output to the `.bbl` and is therefore not present +during `biblatex`style processing. As usual in TeX csv lists, make sure +each element is immediately followed by a comma or the closing +brace---no extraneous whitespace. + +`label` +The field can be used as a label in a bibliography or bibliography list. +Specifying this causes `biblatex`to create several helper macros for the +field so that there are some internal lengths and headings etc. defined. +]] + }, + DeclareDelimAlias = { + arguments = { + {literal = "*", optional = true}, + { + delimiters = {"[", "]"}, + meta = "alias context, ... ", + optional = true + }, + {meta = "alias"}, + {delimiters = {"[", "]"}, meta = "delim context", optional = true}, + {meta = "delim"} + }, + deprecated = true, + details = [[ +```latex +\DeclareDelimAlias*[alias context, ... ]{alias}[delim context]{delim} +``` + +The starred version of `\DeclareDelimAlias` is deprecated in favour of +using unstarred `\DeclareDelimAlias` with optional arguments. + +It assigns the delimiter alias for specific contexts only. The first +optional argument `alias context` holds a list of contexts for which the +assignment is going to be performed. If it is empty or missing the +global/empty context is assumed. The second optional argument +`delim context` specifies the context of the target delimiter. This +argument may not be a list, it can only hold one context. If it is +missing the `alias context` is assumed (if `alias context` is a list, +the assignment is performed separately for each list item), if it is +empty the global context is used. +]] + }, + DeclareDelimFormat = { + arguments = { + {literal = "*", optional = true}, + {delimiters = {"[", "]"}, meta = "context, ... ", optional = true}, + {meta = "name"}, + {meta = "code"} + }, + details = [[ +```latex +\DeclareDelimFormat[context, ... ]{name}{code} +\DeclareDelimFormat*[context, ... ]{name}{code} +``` + +Declares the delimiter macro `name` with the replacement text `code`. If +the optional comma-separated list of `contexts` is given, declare `name` +only for those contexts. `name` defined without any `contexts` behaves +just like the global delimiter definitions which `\newcommand` +gives---just a plain macro with a replacement which can be used as +`\name`. However, you can also call delimiter macros defined in this way +by using `\printdelim`, which is context-aware. The starred version +clears all `context` specific declarations for all `names` first. +]] + }, + DeclareDriverSourcemap = { + arguments = { + { + delimiters = {"[", "]"}, + meta = "datatype=driver", + optional = true + }, + {meta = "specification"} + }, + details = [[ +```latex +\DeclareDriverSourcemap[datatype=driver]{specification} +``` + +This command sets the driver default source mappings for the specified +`driver`. Such mappings are conceptually separate from user mappings +defined with `\DeclareSourcemap` and style mapping defined with +`\DeclareStyleSourcemap`. They consist of mappings which are part of the +driver setup. Users should not normally need to change these. Driver +default mapping are applied after user mappings (`\DeclareSourcemap`) +and style mappings (`\DeclareStyleSourcemap`). These defaults are +described in Appendix ??. The `specification` is identical to that for +`\DeclareSourcemap` but without the `\maps` elements: the +`specification` is just a list of `\map` elements since each +`\DeclareDriverSourcemap` only applies to one datatype driver. See the +default definitions in Appendix ?? for examples. +]] + }, + DeclareEntryOption = { + arguments = { + {delimiters = {"[", "]"}, meta = "datatype", optional = true}, + {meta = "key"}, + {delimiters = {"[", "]"}, meta = "value", optional = true}, + {meta = "code"} + }, + details = [[ +```latex +\DeclareEntryOption[datatype]{key}[value]{code} +``` + +Similar to `\DeclareBibliographyOption` but defines options which are +settable on a per-entry basis in the `options` field from ??. The `code` +is executed whenever `biblatex`prepares the data of the entry for use by +a citation command or a bibliography driver. +]] + }, + DeclareExtradate = { + arguments = {{meta = "specification"}}, + details = [[ +```latex +\DeclareExtradate{specification} +``` + +Defines how `biber`tracks information used to construct the `extradate` +field. This field (see ??) is printed to disambiguate works by the same +author which occur in the same date scope. By default, the date scope is +the year and so two works by the same author within the same year will +have different `extradate` values which are used to disambiguate the +works in the bibliography in the usual manner seen in many authoryear +type styles. The `specification` is one or more `\scope` specifications +which can contain one or more `\field` specifications. Within a +`\scope`, the existence of each `\field` will be checked and if found, +the first `\field` is used and the rest are ignored. This allows a +fallback in case certain fields are not available in all entries. All +`\scope`s are used to track information and `\scope`s should be +specified in decreasing order of generality (e.g. year then month then +day etc) The default definition is: + + \DeclareExtradate{% + \scope{ + \field{labelyear} + \field{year} + } + } + +This means that the `labelyear` field only (or `year` if this does not +exist) will be used to track works by the same author. With the +following datasource entries: + + {} + @BOOK{extra1, + AUTHOR = {John Doe}, + DATE = {2001-01} + } + + @BOOK{extra2, + AUTHOR = {John Doe}, + DATE = {2001-02} + } + +The default definition would result in: + + {} + Doe 2001a + Doe 2001b + +Here, `extradate` only considers the `(`(label)year) information and +since this is identical, disambiguation is required. However, consider +the following definition: + + \DeclareExtradate{% + \scope{ + \field{labelyear} + \field{year} + } + \scope{ + \field{labelmonth} + } + } + +The result would be: + + {} + Doe 2001 + Doe 2001 + +If only years were printed, this would be ambiguous because `extradate` +now considers `labelmonth` and since this differs, no disambiguation is +necessary. Care should therefore be taken to synchronise the printed +information with the `extradate` disambiguation settings. Notice that +the second definition is <month-in-year> disambiguation and quite +different from: + + \DeclareExtradate{% + \scope{ + \field{labelmonth} + } + } + +which is just plain <month> disambiguation which is very unlikely to +be what you ever want to do since this disambiguation only based on +month and ignores the year entirely. `extradate` calculation should +almost always be based on all information down to the resolution you +require. For example, if you wish to disambiguate right down to the hour +level (perhaps useful in large bibliographies of rapidly changing online +material), you would specify something like this: + + \DeclareExtradate{% + \scope{ + \field{labelyear} + \field{year} + } + \scope{ + \field{labelmonth} + } + \scope{ + \field{labelday} + } + \scope{ + \field{labelhour} + } + } + +Entries without the specified granularity of information will +disambiguate at the lowest granularity they contain, so, for example, +with: + + \DeclareExtradate{% + \scope{ + \field{labelyear} + \field{year} + } + \scope{ + \field{labelmonth} + } + } + + {} + @BOOK{extra1, + AUTHOR = {John Doe}, + DATE = {2001} + } + + @BOOK{extra2, + AUTHOR = {John Doe}, + DATE = {2001} + } + +The result would still be: + + {} + Doe 2001a + Doe 2001b + +This command may only be used in the preamble. +]] + }, + DeclareFieldFormat = { + arguments = { + { + delimiters = {"[", "]"}, + meta = "entrytype, ... ", + optional = true + }, + {meta = "format"}, + {meta = "code"} + }, + details = [[ +```latex +\DeclareFieldFormat[entrytype, ... ]{format}{code} +\DeclareFieldFormat*{format}{code} +``` + +Defines the field format `format`. This formatting directive is +arbitrary `code` to be executed by `\printfield`. The value of the field +will be passed to the `code` as its first and only argument. The name of +the field currently being processed is available to the `code` as +`\currentfield`. If an `entrytype` is specified, the format is specific +to that type. The `entrytype` argument may be a comma-separated list of +values. The starred variant of this command is similar to the regular +version, except that all type-specific formats are cleared. +]] + }, + DeclareFieldInputHandler = { + arguments = {{meta = "field"}, {meta = "code"}}, + details = [[ +```latex +\DeclareFieldInputHandler{field}{code} +``` + +This command can be used to define a data input handler for `field` when +it is read from the `.bbl`. The `code` is passed one argument (`#1`), +which contains the input field value, it should then redefine the +command `\NewValue`, which holds the desired output field value. For +example, to ignore the `volumes` field when it appears, you could do + + \DeclareFieldInputHandler{volumes}{\def\NewValue{}} + +Generally, you would want to use `\DeclareSourcemap` (see ??) to remove +and modify fields but this alternative method may be useful in some +circumstances when the emphasis is on appearance rather than data since +the `code` can be arbitraty TeX . + +In general, `\DeclareFieldInputHandler` should not be used to apply +formatting to a field, since that should happen with +`\DeclareFieldFormat`, so the following is just a toy example that shows +how `\DeclareFieldInputHandler` works. + + \DeclareFieldInputHandler{volumes}{\def\NewValue{\textbf{#1}}} +]] + }, + DeclareIndexFieldAlias = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "alias"}, + { + delimiters = {"[", "]"}, + meta = "format entry type", + optional = true + }, + {meta = "format"} + }, + details = [[ +```latex +\DeclareIndexFieldAlias[entry type]{alias}[format entry type]{format} +``` + +Declares `alias` to be an alias for the field format `format`. If an +`entrytype` is specified, the alias is specific to that type. The +`format entry type` is the entry type of the backend format. This is +only required when declaring an alias for a type-specific formatting +directive. +]] + }, + DeclareIndexFieldFormat = { + arguments = { + {literal = "*", optional = true}, + {meta = "format"}, + {meta = "code"} + }, + details = [[ +```latex +\DeclareIndexFieldFormat*{format}{code} +``` + +Defines the field format `format`. This formatting directive is +arbitrary `code` to be executed by `\indexfield`. The value of the field +will be passed to the `code` as its first and only argument. The name of +the field currently being processed is available to the `code` as +`\currentfield`. If an `entrytype` is specified, the format is specific +to that type. The `entrytype` argument may be a comma-separated list of +values. This command is similar to `\DeclareFieldFormat` except that the +data handled by the `code` is not intended to be printed but written to +the index. Note that `\indexfield` will execute the `code` as is, i.e. +the `code` must include `\index` or a similar command. The starred +variant of this command is similar to the regular version, except that +all type-specific formats are cleared. +]] + }, + DeclareIndexListFormat = { + arguments = { + {literal = "*", optional = true}, + {meta = "format"}, + {meta = "code"} + }, + details = [[ +```latex +\DeclareIndexListFormat*{format}{code} +``` + +Defines the literal list format `format`. This formatting directive is +arbitrary `code` to be executed for every item in a list processed by +`\indexlist`. The current item will be passed to the `code` as its only +argument. The name of the literal list currently being processed is +available to the `code` as `\currentlist`. If an `entrytype` is +specified, the format is specific to that type. The `entrytype` argument +may be a comma-separated list of values. This command is similar to +`\DeclareListFormat` except that the data handled by the `code` is not +intended to be printed but written to the index. Note that `\indexlist` +will execute the `code` as is, i.e. the `code` must include `\index` or +a similar command. The starred variant of this command is similar to the +regular version, except that all type-specific formats are cleared. +]] + }, + DeclareIndexNameAlias = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "alias"}, + { + delimiters = {"[", "]"}, + meta = "format entry type", + optional = true + }, + {meta = "format"} + }, + details = [[ +```latex +\DeclareIndexNameAlias[entry type]{alias}[format entry type]{format} +``` + +Declares `alias` to be an alias for the name list format `format`. If an +`entrytype` is specified, the alias is specific to that type. The +`format entry type` is the entry type of the backend format. This is +only required when declaring an alias for a type-specific formatting +directive. +]] + }, + DeclareIndexNameFormat = { + arguments = { + {literal = "*", optional = true}, + {meta = "format"}, + {meta = "code"} + }, + details = [[ +```latex +\DeclareIndexNameFormat*{format}{code} +``` + +Defines the name list format `format`. This formatting directive is +arbitrary `code` to be executed for every name in a list processed by +`\indexnames`. The name of the name list currently being processed is +available to the `code` as `\currentname`. If an `entrytype` is +specified, the format is specific to that type. The `entrytype` argument +may be a comma-separated list of values. The parts of the name will be +passed to the `code` as separate arguments. This command is very similar +to `\DeclareNameFormat` except that the data handled by the `code` is +not intended to be printed but written to the index. Note that +`\indexnames` will execute the `code` as is, i.e. the `code` must +include `\index` or a similar command. The starred variant of this +command is similar to the regular version, except that all type-specific +formats are cleared. +]] + }, + DeclareLabelalphaNameTemplate = { + arguments = { + {delimiters = {"[", "]"}, meta = "name", optional = true}, + {meta = "specification"} + }, + details = [[ +```latex +\DeclareLabelalphaNameTemplate[name]{specification} +``` + +Defines the `labelalphaname` template `name`. The `name` is optional and +defaults to `<global>`. + +Such templates specify how to extract a label string from a name list +when a `\field` specification in `\DeclareLabelalphaTemplate` contains a +name list. +]] + }, + DeclareLabelalphaTemplate = { + arguments = { + {delimiters = {"[", "]"}, meta = "", optional = true}, + {meta = "specification"} + }, + details = [[ +```latex +\DeclareLabelalphaTemplate[]{specification} +``` + +Defines the alphabetic label template for the given entrytypes. If no +entrytypes are specified in the first argument, then the global label +template is defined. The `specification` is an undelimited list of +`\labelelement` directives which specify the elements used to build the +label. Spaces, tabs, and line endings may be used freely to visually +arrange the `specification`. Blank lines are not permissible. This +command may only be used in the preamble. +]] + }, + DeclareLabelname = { + arguments = { + { + delimiters = {"[", "]"}, + meta = "entrytype, ... ", + optional = true + }, + {meta = "specification"} + }, + details = [[ +```latex +\DeclareLabelname[entrytype, ... ]{specification} +``` + +Defines the fields to consider when generating the `labelname` field +(see ??). The `specification` is an ordered list of `\field` commands. +The fields are checked in the order listed and the first field which is +available will be used as `labelname`. This is the default definition: + + \DeclareLabelname{% + \field{shortauthor} + \field{author} + \field{shorteditor} + \field{editor} + \field{translator} + } + +The `labelname` field may be customized globally or on a per-type basis. +If the optional `entrytype` argument is given, the specification applies +to the respective entry type. If not, it is applied globally. The +`entrytype` argument may be a comma-separated list of values. This +command may only be used in the preamble. +]] + }, + DeclareLanguageMappingSuffix = { + arguments = {{meta = "suffix"}}, + details = [[ +```latex +\DeclareLanguageMappingSuffix{suffix} +``` + +This command defines a language file suffix which will be added when +looking for `.lbx` language string definition files. This is intended +for styles which provide their own `.lbx` files so that they will be +used automatically. For example, the APA style defines: + + \DeclareLanguageMappingSuffix{-apa} + +When the document language is <german>, `biblatex`will look for the +file `german-apa.lbx` which defines some APA specific strings and in +turn loads `german.lbx`. If `\DeclareLanguageMapping` is defined for a +language, this overrides `\DeclareLanguageMappingSuffix`. + +The suffix will be applied to other language files loaded recursively by +the loading of a language file. For example, given the suffix defined +above, when loading <ngerman>, `biblatex`will look for the file +`ngerman-apa.lbx` and if this recursively loads <german>, then +biblatex will look for `german-apa.lbx`. Infinite recursion is of course +avoided. +]] + }, + DeclareListAlias = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "alias"}, + { + delimiters = {"[", "]"}, + meta = "format entry type", + optional = true + }, + {meta = "format"} + }, + details = [[ +```latex +\DeclareListAlias[entry type]{alias}[format entry type]{format} +``` + +Declares `alias` to be an alias for the literal list format `format`. If +an `entrytype` is specified, the alias is specific to that type. The +`format entry type` is the entry type of the backend format. This is +only required when declaring an alias for a type-specific formatting +directive. +]] + }, + DeclareListFormat = { + arguments = { + {literal = "*", optional = true}, + {meta = "format"}, + {meta = "code"} + }, + details = [[ +```latex +\DeclareListFormat*{format}{code} +``` + +Defines the literal list format `format`. This formatting directive is +arbitrary `code` to be executed for every item in a list processed by +`\printlist`. The current item will be passed to the `code` as its first +and only argument. The name of the literal list currently being +processed is available to the `code` as `\currentlist`. If an +`entrytype` is specified, the format is specific to that type. The +`entrytype` argument may be a comma-separated list of values. Note that +the formatting directive also handles the punctuation to be inserted +between the individual items in the list. You need to check whether you +are in the middle of or at the end of the list, i.e. whether `listcount` +is smaller than or equal to `liststop`. The starred variant of this +command is similar to the regular version, except that all type-specific +formats are cleared. +]] + }, + DeclareListWrapperAlias = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "alias"}, + { + delimiters = {"[", "]"}, + meta = "format entry type", + optional = true + }, + {meta = "format"} + }, + details = [[ +```latex +\DeclareListWrapperAlias[entry type]{alias}[format entry type]{format} +``` + +Declares `alias` to be an alias for the outer list format `format`. If +an `entrytype` is specified, the alias is specific to that type. The +`format entry type` is the entry type of the backend format. This is +only required when declaring an alias for a type-specific formatting +directive. +]] + }, + DeclareListWrapperFormat = { + arguments = { + {literal = "*", optional = true}, + {meta = "format"}, + {meta = "code"} + }, + details = [[ +```latex +\DeclareListWrapperFormat*{format}{code} +``` + +Defines the list wrapper format `format`. This formatting directive is +arbitrary `code` to be executed once for the entire list processed by +`\printlist`. The name of the literal list currently being processed is +available to the `code` as `\currentlist`. If an `entrytype` is +specified, the format is specific to that type. The `entrytype` argument +may be a comma-separated list of values. The starred variant of this +command is similar to the regular version, except that all type-specific +formats are cleared. +]] + }, + DeclareMultiCiteCommand = { + arguments = { + {meta = "command"}, + {delimiters = {"[", "]"}, meta = "wrapper", optional = true}, + {meta = "cite"}, + {meta = "delimiter"} + }, + details = [[ +```latex +\DeclareMultiCiteCommand{command}[wrapper]{cite}{delimiter} +``` + +This command defines <multicite> commands (??). The `command` is the +multicite command to be defined, for example `\cites`. It is +automatically made robust. Multicite commands are built on top of +backend commands defined with `\DeclareCiteCommand` and the `cite` +argument specifies the name of the backend command to be used. Note that +the wrapper of the backend command (i.e. the `wrapper` argument passed +to `\DeclareCiteCommand`) is ignored. Use the optional `wrapper` +argument to specify an alternative wrapper. The `delimiter` is the +string to be printed as a separator between the individual citations in +the list. This will typically be `\multicitedelim`. The following +examples are real definitions taken from `biblatex.def`: + + \DeclareMultiCiteCommand{\cites}% + {\cite}{\multicitedelim} + \DeclareMultiCiteCommand{\parencites}[\mkbibparens]% + {\parencite}{\multicitedelim} + \DeclareMultiCiteCommand{\footcites}[\mkbibfootnote]% + {\footcite}{\multicitedelim} +]] + }, + DeclareNameFormat = { + arguments = { + {literal = "*", optional = true}, + {meta = "format"}, + {meta = "code"} + }, + details = [[ +```latex +\DeclareNameFormat*{format}{code} +``` + +Defines the name list format `format`. This formatting directive is +arbitrary `code` to be executed for every name in a list processed by +`\printnames`. If an `entrytype` is specified, the format is specific to +that type. The `entrytype` argument may be a comma-separated list of +values. The individual parts of a name will be available in +automatically created macros (see below). The default data mode defines +four name part which correspond to the standard BibTeX name parts +arguments: + +family +The family name(s), know as <last> in BibTeX . If a name consists of +a single part only (for example, <Aristotle>), this part will be +treated as the family name. + +given +The given name(s). Note that given names are referred to as the +<first> names in the BibTeX file format documentation. + +prefix +Any name prefices, for example von, van, of, da, de, del, della, etc. +Note that name prefices are referred to as the <von> part of the name +in the BibTeX file format documentation. + +suffix +Any name suffices, for example Jr, Sr. Note that name suffices are +referred to as the <Jr> part of the name in the BibTeX file format +documentation. + +The value of the datamodel <nameparts> constant (see ??) creates two +macros for each name part in the datamodel for the name. So, for +example, in the default data model, name formats will have defined the +following macros: + + \namepartprefix + \namepartprefixi + \namepartfamily + \namepartfamilyi + \namepartsuffix + \namepartsuffixi + \namepartgiven + \namepartgiveni + +If a certain part of a name is not available, the corresponding macro +will be empty, hence you may use, for example, the `etoolbox` tests like +`\ifdefvoid` to check for the individual parts of a name. The name of +the name list currently being processed is available to the `code` as +`\currentname`. Note that the formatting directive also handles the +punctuation to be inserted between separate names and between the +individual parts of a name. You need to check whether you are in the +middle of or at the end of the list, i.e. whether `listcount` is smaller +than or equal to `liststop`. See also ??. The starred variant of this +command is similar to the regular version, except that all type-specific +formats are cleared. +]] + }, + DeclareNameInputHandler = { + arguments = {{meta = "name"}, {meta = "code"}}, + details = [[ +```latex +\DeclareNameInputHandler{name}{code} +``` + +As `\DeclareFieldInputHandler` but for names. Within the `code`, the +macro `\NewValue` contains the value of the name, `\NewCount` contains +the number of individual names in the name and `\NewOption` contains any +per-name options passed in the `.bbl`. Note that `\NewValue` as well as +the single argument to `code` contain the internal representation of the +name list. +]] + }, + DeclareNameWrapperFormat = { + arguments = { + {literal = "*", optional = true}, + {meta = "format"}, + {meta = "code"} + }, + details = [[ +```latex +\DeclareNameWrapperFormat*{format}{code} +``` + +Defines the list wrapper format `format`. This formatting directive is +arbitrary `code` to be executed once for the entire name list processed +by `\printnames`. The name of the literal list currently being processed +is available to the `code` as `\currentname`. If an `entrytype` is +specified, the format is specific to that type. The `entrytype` argument +may be a comma-separated list of values. The starred variant of this +command is similar to the regular version, except that all type-specific +formats are cleared. +]] + }, + DeclareNoinit = { + arguments = {{meta = "specification"}}, + details = [[ +```latex +\DeclareNoinit{specification} +``` + +Defines regular expressions to strip from names before generating +initials. The `specification` is an undelimited list of `\noinit` +directives which specify the regular expressions to remove from the +name. Spaces, tabs and line endings may be used freely to visually +arrange the `specification`. Blank lines are not permissible. This +command may only be used in the preamble. +]] + }, + DeclareNolabel = { + arguments = {{meta = "specification"}}, + details = [[ +```latex +\DeclareNolabel{specification} +``` + +Defines regular expressions to strip from any field before generating a +label part for the field. The `specification` is an undelimited list of +`\nolabel` directives which specify the regular expressions to remove +from fields. Spaces, tabs and line endings may be used freely to +visually arrange the `specification`. Blank lines are not permissible. +This command may only be used in the preamble. +]] + }, + DeclareNolabelwidthcount = { + arguments = {{meta = "specification"}}, + details = [[ +```latex +\DeclareNolabelwidthcount{specification} +``` + +Defines regular expressions to ignore from any field when counting +characters in fixed-width substrings. The `specification` is an +undelimited list of `\nolabelwidthcount` directives which specify the +regular expressions to ignore when counting characters for fixed-width +substrings. Spaces, tabs and line endings may be used freely to visually +arrange the `specification`. Blank lines are not permissible. This +command may only be used in the preamble. +]] + }, + DeclareNonamestring = { + arguments = {{meta = "specification"}}, + details = [[ +```latex +\DeclareNonamestring{specification} +``` + +Defines regular expressions to strip from name fields when generating +`fullhash` and `uniquename`. The `specification` is an undelimited list +of `\nonamestring` directives which specify the regular expressions to +remove from particular name fields. Spaces, tabs and line endings may be +used freely to visually arrange the `specification`. Blank lines are not +permissible. This command may only be used in the preamble. +]] + }, + DeclareNosort = { + arguments = {{meta = "specification"}}, + details = [[ +```latex +\DeclareNosort{specification} +``` + +Defines regular expressions to strip from particular fields or types of +fields when sorting. The `specification` is an undelimited list of +`\nosort` directives which specify the regular expressions to remove +from particular fields or type of field. Spaces, tabs and line endings +may be used freely to visually arrange the `specification`. Blank lines +are not permissible. This command may only be used in the preamble. +]] + }, + DeclareNumChars = { + arguments = {{literal = "*", optional = true}, {meta = "characters"}}, + details = [[ +```latex +\DeclareNumChars{characters} +\DeclareNumChars*{characters} +``` + +This command configures the `\ifnumeral`, `\ifnumerals`, and `\ifpages` +tests from ??. The setup will also affect `\iffieldnum`, `\iffieldnums`, +`\iffieldpages` as well as `\mkpageprefix` and `\mkpagetotal`. The +`characters` argument is an undelimited list of characters which are to +be considered as being part of a number. The regular version of this +command replaces the current setting, the starred version appends its +argument to the current list. The default setting is: + + \DeclareNumChars{.} + +This means that a (section or other) number like <3.4.5> will be +considered as a number. Note that Arabic and Roman numerals are detected +by default, there is no need to declare them explicitly. +]] + }, + DeclarePageCommands = { + arguments = {{literal = "*", optional = true}, {meta = "commands"}}, + details = [[ +```latex +\DeclarePageCommands*{commands} +``` + +This command is similar to `\DeclareRangeCommands`, except that it only +affects the `\ifpages` and `\iffieldpages` tests but not `\ifnumerals` +and `\iffieldnums`. The default setting is: + + \DeclarePageCommands{\pno\ppno} +]] + }, + DeclarePrefChars = { + arguments = {{literal = "*", optional = true}, {meta = "characters"}}, + details = [[ +```latex +\DeclarePrefChars{characters} +\DeclarePrefChars*{characters} +``` + +This command declares characters that are to be treated specially when +testing to see if `\bibnamedelimc` is to be inserted between a name +prefix and a family name. If a character is in the list of `characters`, +`\bibnamedelimc` is not inserted. It is used to allow abbreviated name +prefices like <d'Argent> where no space should be inserted after the +apostrophe. The starred version appends its argument to the list of +prefix characters, the unstarred version replaces the current setting. +The default setting is: + + \DeclarePrefChars{'-} + +For engines that fully support Unicode these defaults are extended with + + [escapeinside={(*@}{@*)}] + \DeclarePrefChars*{(*@’@*)} +]] + }, + DeclarePresort = { + arguments = { + { + delimiters = {"[", "]"}, + meta = "entrytype, ... ", + optional = true + }, + {meta = "string"} + }, + details = [[ +```latex +\DeclarePresort[entrytype, ... ]{string} +``` + +Specifies a string to be used to automatically populate the `presort` +field of entries without a `presort` field. The `presort` may be defined +globally or on a per-type basis. If the optional `entrytype` argument is +given, the `string` applies to the respective entry type. If not, it +serves as the global default value. Specifying an `entrytype` in +conjunction with a blank `string` will clear the type-specific setting. +The `entrytype` argument may be a comma-separated list of values. This +command may only be used in the preamble. +]] + }, + DeclarePrintbibliographyDefaults = { + arguments = {{meta = "key=value, ... "}}, + details = [[ +```latex +\DeclarePrintbibliographyDefaults{key=value, ... } +``` + +This command can be used to globally set defaults for some options to +`\printbibliography`, the `\bibby...` bibliography commands and +`\printbibheading`. The supported keys are + +- `env` + +- `heading` + +- `title` + +- `prenote` + +- `postnote` + +- `filter` +]] + }, + DeclareQuotePunctuation = { + arguments = {{meta = "characters"}}, + details = [[ +```latex +\DeclareQuotePunctuation{characters} +``` + +This command controls <American-style> punctuation. The `\mkbibquote` +wrapper from ?? can interact with the punctuation facilities discussed +in ??. Punctuation marks after `\mkbibquote` will be moved inside the +quotes if they have been registered with `\DeclareQuotePunctuation`. +Note that `characters` is an undelimited list of characters. Valid +`characters` are period, comma, semicolon, colon, exclamation and +question mark. Here is an example: + + \DeclareQuotePunctuation{.,} + +Executing `\DeclareQuotePunctuation{}` is equivalent to disabling this +feature. This is the package default. Since this feature is language +specific, this command must be used in the argument to +`\DefineBibliographyExtras` (when used in the preamble) or +`\DeclareBibliographyExtras` (when used in a localisation module). See +?? for details. See also ??. +]] + }, + DeclareRangeChars = { + arguments = {{literal = "*", optional = true}, {meta = "characters"}}, + details = [[ +```latex +\DeclareRangeChars*{characters} +``` + +This command configures the `\ifnumerals` and `\ifpages` tests from ??. +The setup will also affect `\iffieldnums` and `\iffieldpages` as well as +`\mkpageprefix` and `\mkpagetotal`. The `characters` argument is an +undelimited list of characters which are to be considered as range +indicators. The regular version of this command replaces the current +setting, the starred version appends its argument to the current list. +The default setting is: + + \DeclareRangeChars{~,;-+/} + +For engines that fully support Unicode these defaults are extended with + + [escapeinside={(*@}{@*)}] + \DeclareRangeChars*{(*@–—@*)} + +This means that strings like <3--5>, <35+>, <8/9> and so on +will be considered as a range by `\ifnumerals` and `\ifpages`. Non-range +characters in such strings are recognized as numbers. So strings like +<3a--5a> and <35b+> are not deemed to be ranges by default. See +also ?? for further details. +]] + }, + DeclareRangeCommands = { + arguments = {{literal = "*", optional = true}, {meta = "commands"}}, + details = [[ +```latex +\DeclareRangeCommands*{commands} +``` + +This command is similar to `\DeclareRangeChars`, except that the +`commands` argument is an undelimited list of commands which are to be +considered as range indicators. The regular version of this command +replaces the current setting, the starred version appends its argument +to the current list. The default list is rather long and should cover +all common cases; here is a shorter example: + + \DeclareRangeCommands{\&\bibrangedash\textendash\textemdash\psq\psqq} + +See also ?? for further details. +]] + }, + DeclareRedundantLanguages = { + arguments = {{meta = "language, language, ..."}, {meta = "langid, langid, ..."}}, + details = [[ +```latex +\DeclareRedundantLanguages{language, language, ...}{langid, langid, ...} +``` + +This command provides the language mappings required by the `clearlang` +option from ??. The `language` is the string given in the `language` +field (without the optional `lang` prefix); `langid` is +`babel`/`polyglossia`'s language identifier, as given in the optional +argument of `\usepackage` when loading `babel` or the argument of +`\setdefaultlanguage` or `\setotherlanguages` when using `polyglossia`. +This command may be used in `lbx` files or in the document preamble. +Here are some examples: + + \DeclareRedundantLanguages{french}{french} + \DeclareRedundantLanguages{german}{german,ngerman,austrian,naustrian, + nswissgerman,swissgerman} + \DeclareRedundantLanguages{english,american}{english,american,british, + canadian,australian,newzealand,USenglish,UKenglish} + +Note that this feature needs to be enabled globally with the `clearlang` +option from ??. If it is disabled, all mappings will be ignored. If the +`langid` parameter is blank, `biblatex`will clear the mappings for the +corresponding `language`, i.e. the feature will be disabled for this +`language` only. +]] + }, + DeclareRefcontext = { + arguments = {{meta = "name"}, {meta = "key=value, ... "}}, + details = [[ +```latex +\DeclareRefcontext{name}{key=value, ... } +``` + +Declares a named reference context with name `name`. The `key=value` +options define the context attributes. All context attributes are +optional and default to the global settings if absent. The valid options +are: + +`sorting=<name>` +Specify a sorting template defined previously with +`\DeclareSortingTemplate`. This template is used to determine which data +to retrieve and/or print for an entry in the commands inside the +context. + +`sortingnamekeytemplatename=<name>` +Specify a sorting name key template defined previously with +`\DeclareSortingNamekeyTemplate`. This template is used to construct +sorting keys for names inside the context. The template name can also be +specified (in increasing order of preference) per-entry, per-name list +and per-name. See ?? for information on setting per-option, per-namelist +and per-name options. + +`uniquenametemplatename=<name>` +Specify a uniquename template defined previously with +`\DeclareUniquenameTemplate` (see ??). This template is used to +calculate uniqueness information for names inside the context. The +template name can also be specified (in increasing order of preference) +per-entry, per-name list and per-name. See ?? for information on setting +per-option, per-namelist and per-name options. + +`labelalphanametemplatename=<name>` +Specify a template defined previously with +`\DeclareLabelalphaNameTemplate` (see ??). This template is used to +construct name parts of alphabetic labels for names inside the context. +The template name can also be specified (in increasing order of +preference) per-entry, per-name list and per-name. See ?? for +information on setting per-option, per-namelist and per-name options. + +`nametemplates=<name>` +A convenience meta-option which sets `sortingnamekeytemplate`, +`uniquenametemplate` and `labelalphanametemplate` to the same template +name. This option can also be specified (in increasing order of +preference) per-entry, per-name list and per-name. See ?? for +information on setting per-option, per-namelist and per-name options. + +`labelprefix=<string>` +This option applies to numerical citation/bibliography styles only and +requires that the `defernumbers` option from ?? be enabled globally. +Setting this option will implicitly enable `resetnumbers` for the any +`\printbibliography` in the scope of the context (unless overridden by a +user-specified value for `resetnumbers`). The option assigns the +`string` as a prefix to all entries in the reference context. For +example, if the `string` is `A`, the numerical labels printed will be +`[A1]`, `[A2]`, `[A3]`, etc. This is useful for subdivided numerical +bibliographies where each subbibliography uses a different prefix. The +`string` is available to styles in the `labelprefix` field of all +affected entries. Note that the `string` is fully expanded, which means +that you can use context-dependent macros like `\thechapter`, but not +unexpandable commands such as `\dag`. If you need to pass unexpandable +code to `string`, protect it from expansion with `\detokenize`. See ?? +for details. +]] + }, + DeclareSortExclusion = { + arguments = {{meta = "entrytype, ... "}, {meta = "field, ... "}}, + details = [[ +```latex +\DeclareSortExclusion{entrytype, ... }{field, ... } +``` + +Specifies fields to be excluded from sorting on a per-type basis. The +`entrytype` argument and the `field` argument may be a comma-separated +list of values. A blank `field` argument will clear all exclusions for +this `entrytype`. A value of <\*> for `entrytype` will exclude +`field,…` for every entrytype. This is equivalent to simply deleting the +field from the sorting specification and is only normally used in +combination with `\DeclareSortInclusion` when one wishes to exclude a +field for all but explicitly included entrytypes. See example in +`\DeclareSortInclusion` below. This command may only be used in the +preamble. +]] + }, + DeclareSortingNamekeyTemplate = { + arguments = { + {delimiters = {"[", "]"}, meta = "name", optional = true}, + {meta = "specification"} + }, + details = [[ +```latex +\DeclareSortingNamekeyTemplate[name]{specification} +``` + +Defines how the sorting keys for names are constructed. This can change +the sorting order of names arbitrarily because you can choose how to put +together the name parts when constructing the string to compare when +sorting. The sorting key construction template so defined is called +`name` which defaults to «global» if this optional parameter is absent. +When constructing the sorting key for a name, a sorting key for each +name part is constructed and the key for each name is formed into an +ordered key list with a special internal separator. The point of this +option is to accommodate languages or situations where sorting of names +needs to be customised (for example, Icelandic names are sometimes +sorted by given names rather than by family names). This macro may be +used multiple times to define templates with different names which can +then be referred to later. Sorting name key templates can be specified +at the following scopes, in order of increasing precedence: + +- The default template defined without the optional name argument + +- Given as the `sortingnamekeytemplate` option to a reference context + (see ??) + +- Given as a per-entry option `sortnamekeytemplate` in a bibliography + data source entry + +- Given as a per-namelist option `sortnamekeytemplate` + +- Given as a per-name option `sortnamekeytemplate` + +By default there is only a global template which has the following +`specification`: + + \DeclareSortingNamekeyTemplate{ + \keypart{ + \namepart[use=true]{<<prefix>>} + \namepart{<<family>>} + } + \keypart{ + \namepart{<<given>>} + } + \keypart{ + \namepart{<<suffix>>} + } + \keypart{ + \namepart[use=false]{<<prefix>>} + } + } + +This means that the key is constructed by concatenating, in order, the +name prefix (only if the `useprefix` option is true) with the family +name(s), the given names(s), the name suffix and then the name prefix +(only if the `useprefix` option is false). +]] + }, + DeclareSortingTemplate = { + arguments = { + {delimiters = {"[", "]"}, meta = "options", optional = true}, + {meta = "name"}, + {meta = "specification"} + }, + details = [[ +```latex +\DeclareSortingTemplate[options]{name}{specification} +``` + +Defines the sorting template `name`. The `name` is the identifier passed +to the `sorting` option (??) when selecting the sorting template. The +`\DeclareSortingTemplate` command supports the following optional +arguments: + +`locale={locale}` +The locale for the sorting template which then overrides the global +sorting locale in the `sortlocale` option discussed in ??. + +The `specification` is an undelimited list of `\sort` directives which +specify the elements to be considered in the sorting process. Spaces, +tabs, and line endings may be used freely to visually arrange the +`specification`. Blank lines are not permissible. This command may only +be used in the preamble. +]] + }, + DeclareSourcemap = { + arguments = {{meta = "specification"}}, + details = [[ +```latex +\DeclareSourcemap{specification} +``` + +Defines source data modification (mapping) rules which can be used to +perform any combination of the following tasks: + +- Map data source entrytypes to different entrytypes + +- Map datasource fields to different fields + +- Add new fields to an entry + +- Remove fields from an entry + +- Modify the contents of a field using standard Perl regular + expression match and replace[1] + +- Restrict any of the above operations to entries coming from + particular datasources which you defined in `\addresource` macros + +- Restrict any of the above operations to entries only of a certain + entrytype + +- Restrict any of the above operations to entries in a particular + reference section + +The `specification` is an undelimited list of `\maps` directives which +specify containers for mappings rules applying to a particular data +source type (??). Spaces, tabs, and line endings may be used freely to +visually arrange the `specification`. Blank lines are not permissible. +This command may only be used in the preamble and can be used multiple +times, the maps being run in order of definition. + +[1] See for example <https://perldoc.perl.org/perlretut.html>, +<https://perldoc.perl.org/perlrequick.html> and +<https://perldoc.perl.org/perlre.html>. There are many more resources +available about regular expessions in Perl. +]] + }, + DeclareStyleSourcemap = { + arguments = {{meta = "specification"}}, + details = [[ +```latex +\DeclareStyleSourcemap{specification} +``` + +This command sets the source mappings used by a style. Such mappings are +conceptually separate from user mappings defined with +`\DeclareSourcemap` and are applied directly after user maps. The syntax +is identical to `\DeclareSourcemap`. This command is provided for style +authors so that any maps defined for the style do not interfere with +user maps or the default driver maps defined with +`\DeclareDriverSourcemap`. This command is for use in style files and +can be used multiple times, the maps being run in order of definition. +]] + }, + DeclareUniquenameTemplate = { + arguments = { + {delimiters = {"[", "]"}, meta = "name", optional = true}, + {meta = "specification"} + }, + details = [[ +```latex +\DeclareUniquenameTemplate[name]{specification} +``` + +Defines the `uniquename` template `name`. The `name` is optional and +defaults to `<global>`. + +The `specification` is an ordered list of `\namepart` commands which +define the nameparts to use in determining the uniquename information. +]] + }, + DefaultInheritance = { + arguments = { + {delimiters = {"[", "]"}, meta = "exceptions", optional = true}, + {meta = "options"} + }, + details = [[ +```latex +\DefaultInheritance[exceptions]{options} +``` + +Configures the default inheritance behavior. This command may only be +used in the preamble. The default behavior may be customized be setting +the following `options`: + +`all` +Whether or not to inherit all fields from the parent by default. + +`all=true` means that the child entry inherits all fields from the +parent, unless a more specific inheritance rule has been set up with +`\DeclareDataInheritance`. If an inheritance rule is defined for a +field, data inheritance is controlled by that rule. `all=false` means +that no data is inherited from the parent by default and each field to +be inherited requires an explicit inheritance rule set up with +`\DeclareDataInheritance`. The package default is `all=true`. + +`override` +Whether or not to overwrite target fields with source fields if both are +defined. This applies both to automatic inheritance and to explicit +inheritance rules. The package default is `override=false`, i.e. +existing fields of the child entry are not overwritten. + +`ignore=<csv list of uniqueness options>` +This option takes a comma-separated list of one of more of +<singletitle>, <uniquetitle>, <uniquebaretitle> and/or +<uniquework>. The purpose of this option is to ignore tracking +information for these three options when the field which would trigger +the tracking (??) is inherited. An example---Suppose that you have +several `book` entries which all crossref a `mvbook` from which they get +their `author` field. You might reasonably want the `\ifsingletitle` +test to return <true> for this author as their only <work> is the +`mvbook`. Similar comments would apply to situations involving the +`\ifuniquetitle`, `\ifuniquebaretitle` and `\ifuniquework` tests. The +`ignore` option lists which of these should have their tracking +information ignored when the fields which would trigger them are +inherited. The idea is that the presence of an inherited field does not +contribute towards the determination of whether some combination of +name/title is unique in the bibliographic data. For example, this +modified default setting would ignore `singletitle` and `uniquetitle` +tracking: + + \DefaultInheritance{ignore={singletitle,uniquetitle}, all=true, override=false} + +Of course, the ignoring of tracking does nothing if the fields inherited +do not play a role in tracking. Only the fields listed in ?? are +relevant to this option. + +The optional `exceptions` are an undelimited list of `\except` +directives. Spaces, tabs, and line endings may be used freely to +visually arrange the `exceptions`. Blank lines are not permissible. +]] + }, + DefineBibliographyStrings = { + arguments = {{meta = "language"}, {meta = "definitions"}}, + details = [[ +```latex +\DefineBibliographyStrings{language}{definitions} +``` + +This command is used to define localisation strings. The `language` must +be a language name known to the `babel`/`polyglossia` packages, i.e. one +of the identifiers listed in ?? on page ??. The `definitions` are +`key=value`pairs which assign an expression to an identifier: + + \DefineBibliographyStrings{american}{% + bibliography = {Bibliography}, + shorthands = {Abbreviations}, + editor = {editor}, + editors = {editors}, + } + +A complete list of all keys supported by default is given is ??. Note +that all expressions should be capitalized as they usually are when used +in the middle of a sentence. The `biblatex`package will automatically +capitalize the first word when required at the beginning of a sentence. +Expressions intended for use in headings should be capitalized in a way +that is suitable for titling. In contrast to +`\DeclareBibliographyStrings`, `\DefineBibliographyStrings` overrides +both the full and the abbreviated version of the string. See ?? for +further details. +]] + }, + DeprecateField = { + arguments = {{meta = "field"}, {meta = "message"}}, + details = [[ +```latex +\DeprecateField{field}{message} +\DeprecateList{list}{message} +\DeprecateName{name}{message} +``` + +When an attempt is made to print `field`, `list`, `name`, a deprecation +warning is issued with the additional `message`. This aids style authors +who are changing field names in their style. Note that the deprecated +item must no longer be defined in the datamodel for this to work; +`field`, `list` or `name` cannot be listed anywhere as an argument to +`\DeclareDatamodelFields`. +]] + }, + DeprecateIndexFieldFormatWithReplacement = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "alias"}, + { + delimiters = {"[", "]"}, + meta = "format entry type", + optional = true + }, + {meta = "format"} + }, + details = [[ +```latex +\DeprecateIndexFieldFormatWithReplacement[entry type]{alias}[format entry type]{format} +``` + +Similar to `\DeprecateFieldFormatWithReplacement` but for index field +formats. +]] + }, + DeprecateIndexNameFormatWithReplacement = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "alias"}, + { + delimiters = {"[", "]"}, + meta = "format entry type", + optional = true + }, + {meta = "format"} + }, + details = [[ +```latex +\DeprecateIndexNameFormatWithReplacement[entry type]{alias}[format entry type]{format} +``` + +Similar to `\DeprecateFieldFormatWithReplacement` but for index name +formats. +]] + }, + DeprecateList = { + arguments = {{meta = "list"}, {meta = "message"}}, + details = "$ref:biblatex.sty#/commands/DeprecateField/details" + }, + DeprecateListFormatWithReplacement = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "alias"}, + { + delimiters = {"[", "]"}, + meta = "format entry type", + optional = true + }, + {meta = "format"} + }, + details = [[ +```latex +\DeprecateListFormatWithReplacement[entry type]{alias}[format entry type]{format} +``` + +Similar to `\DeprecateFieldFormatWithReplacement` but for list formats. +]] + }, + DeprecateListWithReplacement = { + arguments = {{meta = "list"}, {meta = "replacement"}}, + details = [[ +```latex +\DeprecateListWithReplacement{list}{replacement} +\DeprecateNameWithReplacement{name}{replacement} +``` + +Similar to `\DeprecateField`, `\DeprecateList` and `\DeprecateName`. The +commands do not only issue a deprecation warning, they try to define a +replacement for the deprecated field that is printed in its stead. The +`\replacement` must be of the same type as the deprecated `field`, +`list` or `name`. If the formatting of `replacement` should be applied +when printing the deprecated field, that needs to be requested with +`\DeclareFieldAlias` (see ??). Note that the deprecated item must no +longer be defined in the datamodel for this work; `field`, `list` or +`name` cannot be listed anywhere as an argument to +`\DeclareDatamodelFields`. +]] + }, + DeprecateListWrapperFormatWithReplacement = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "alias"}, + { + delimiters = {"[", "]"}, + meta = "format entry type", + optional = true + }, + {meta = "format"} + }, + details = [[ +```latex +\DeprecateListWrapperFormatWithReplacement[entry type]{alias}[format entry type]{format} +``` + +Similar to `\DeprecateFieldFormatWithReplacement` but for outer list +formats. +]] + }, + DeprecateName = { + arguments = {{meta = "name"}, {meta = "message"}}, + details = "$ref:biblatex.sty#/commands/DeprecateField/details" + }, + DeprecateNameWithReplacement = { + arguments = {{meta = "name"}, {meta = "replacement"}}, + details = "$ref:biblatex.sty#/commands/DeprecateListWithReplacement/details" + }, + ExecuteBibliographyOptions = { + arguments = { + { + delimiters = {"[", "]"}, + meta = "entrytype, ... ", + optional = true + }, + {meta = "key=value, ... "} + }, + details = [[ +```latex +\ExecuteBibliographyOptions[entrytype, ... ]{key=value, ... } +``` + +This command may also be used in the configuration file to modify the +default setting of a package option. Certain options are also settable +on a per-type basis. In this case, the optional `entrytype` argument +specifies the entry type. The `entrytype` argument may be a +comma-separated list of values. +]] + }, + Fvolcites = { + action = "cite", + details = [[ +```latex +\Fvolcites(multiprenote)(multipostnote)[prenote]{volume}[pages]{key}|\\...|[prenote]{volume}[pages]{key} +``` + +The multicite version of `\fvolcite` and `\Fvolcite`, respectively. +]] + }, + InheritBibliographyExtras = { + arguments = {{meta = "language"}}, + details = [[ +```latex +\InheritBibliographyExtras{language} +``` + +This command is only available in `lbx` files. It copies the +bibliography extras for `language` to the current language, as specified +by the name of the `lbx` file. +]] + }, + MakeCapital = { + arguments = {{meta = "text"}}, + details = [[ +```latex +\MakeCapital{text} +``` + +Similar to `\MakeUppercase` but only converts the first printable +character in `text` to uppercase. Note that the restrictions that apply +to `\MakeUppercase` also apply to this command. Namely, all commands in +`text` must either be robust or prefixed with `\protect` since the +`text` is expanded during capitalization. Apart from US-ASCII characters +and the standard accent commands, this command also handles the active +characters of the `inputenc` package as well as the shorthands of the +`babel` package. If the `text` starts with a control sequence, nothing +is capitalized. This command is robust. +]] + }, + MakeSentenceCase = { + arguments = {{literal = "*", optional = true}, {meta = "text"}}, + details = [[ +```latex +\MakeSentenceCase*{text} +``` + +Converts its `text` argument to sentence case, i.e. the first word is +capitalized and the remainder of the string is converted to lowercase. +This command is robust. The starred variant differs from the regular +version in that it considers the language of the entry, as specified in +the `langid` field. If the `langid` field is defined and holds a +language declared with `\DeclareCaseLangs` (see below)[1], then the +sentence case conversion is performed. If the `langid` field is +undefined, then the language list declared with `\DeclareCaseLangs` is +checked for the presence of the main document language derived from the +`language` option. If found, sentence case conversion is performed, if +not, the `text` is not altered in any way. It is recommended to use +`\MakeSentenceCase*` rather than the regular variant in formatting +directives. + +Depending on the option `casechanger` `\MakeCaseChange` and +`\MakeCaseChange*` are either implemented using the `expl3` module +`l3text` or original LaTeX2ɛ code. + +Both variants support the traditional BibTeX convention for `bib` files +that anything wrapped in a pair of curly braces is not modified when +changing the case. For example: + + \MakeSentenceCase{an Introduction to LaTeX} + \MakeSentenceCase{an Introduction to {LaTeX}} + +would yield: + + {} + An introduction to latex + An introduction to LaTeX + +In `bib` files designed with traditional BibTeX in mind, it has been +fairly common to only wrap single letters in braces to prevent +case-changing: + + {} + title = {An Introduction to {L}a{T}e{X}} + +The problem with this convention is that the braces will suppress the +kerning on both sides of the enclosed letter. It is preferable to wrap +the entire word in braces as shown in the first example. Macros in +titles must also be protected with braces + + {} + title = {The {\TeX book}}, + +The behaviour of `\MakeSentenceCase` differs slightly between the +`latex2e` and `expl3` implementation. Generally speaking, the `expl3` +code is closer to the BibTeX behaviour of `change.case$`. It is also +better equipped to deal with non-US-ASCII input and macros than the +`latex2e` implementation. `\MakeSentenceCase` behaves as follows. + +- The first letter of its argument is capitalised with + `\MakeUppercase`. This is different from BibTeX 's `change.case$`, + which does not touch the first letter of its argument. + + Note that with the `latex2e` code a pair of braces that starts with + a control sequence will be treated as a single character for + capitalisation purposes. This means that the entire argument of a + command protected with a single pair of braces is capitalised. + +- With the `latex2e` code expandable commands are expanded before the + case change, which means that the case change applies to the + replacement text. Unexpandable commands are not touched. + + BibTeX does not interpret macros and therefore passes commands + through unchanged (this does not necessarily apply to the + *arguments* of those commands). The `expl3` implementation also does + not expand commands and only applies case change to the arguments. + +- Text wrapped in one or more pairs of braces is protected from case + change *unless* it starts with a control sequence. This is the same + behaviour as with BibTeX . Note that the braces could either be + explicit groups or argument delimiters. + +- Text in a single pair of braces that starts with a control sequence + is not protected and will be subject to case changes. Note that this + need not apply to braces that are argument delimiters, in fact the + `latex2e` implementation of `\MakeSentenceCase` may in some cases + produce an error or otherwise undesirable output if the argument of + a command starts with a control sequence. BibTeX 's case change + function does not differentiate between argument delimiters and + brace groups and always subjects text at brace level 1 to case + change if it starts with a control sequence. + +For most intents and purposes the following rules should give a sensible +result. + +- Protect all words whose case should not be changed by wrapping them + in one pair of braces. + +- If words are already in the braced argument of a command such as + `\mkbibquote` or `\emph`, they are automatically protected. + + - To *undo* this protection wrap the command in braces again. + + - It is not possible to selectively re-apply protection if it has + been undone with an additional pair of braces. If a more + fine-grained control is needed, work-arounds like splitting the + argument could be tried. + +- While it is possible to protect words from case change at the + beginning of a field with a pair of braces, it is not possible to + undo the case protection that a command automatically implies by + wrapping it in braces in that position. In that case work-arounds + are necessary. + + + + {} + title = {The Story of {HMS} \emph{Erebus} + in {\emph{Really}} Strong Wind}, + +would be converted to sentence case by `\MakeSentenceCase` as + +> The story of HMS *Erebus* in *really* strong wind + +If the `expl3` implementation of the case changing functions is +selected, the BibTeX case protection behaviour can be exchanged for a +slightly simpler version. When `bibtexcaseprotection` set to `false`, +braces no longer automatically imply case protection. Instead words can +be protected from case change with `\NoCaseChange`. The examples from +above would then read + + {} + title = {An Introduction to \NoCaseChange{LaTeX}}, + title = {The Story of \NoCaseChange{HMS \emph{Erebus}} + in \emph{Really} Strong Wind}, + +Generally, this option should allow for a saner case protection input, +because curly braces are no longer overloaded with different levels of +meaning, but it is a big departure from the standard case protection +input that has been with the LaTeX world for a long time. + +Due to its complex implementation `\MakeSentenceCase` can not accept +arbitrary input, it only safely operates on raw text or field data. In +the standard styles the `title` and other `title`-like field formats do +not work together with `\MakeSentenceCase` because of their argument +structure, so the standard styles offer a dedicated `titlecase` field +format to apply this command. To enable sentence casing in standard +styles for languages that support it you would use: + + \DeclareFieldFormat{titlecase}{<<\MakeSentenceCase*{#1}>>} + +Sentence casing can then be disabled by resetting that field format to + + \DeclareFieldFormat{titlecase}{<<#1>>} + +Custom styles may follow a different approach, but style authors are +encouraged to apply the same general ideas to their styles. + +[1] By default, converting to sentence case is enabled for the following +language identifiers: `american`, `british`, `canadian`, `english`, +`australian`, `newzealand` as well as the aliases `USenglish` and +`UKenglish`. Use `\DeclareCaseLangs` to extend or change this list. +]] + }, + NewBibliographyString = { + arguments = {{meta = "key"}}, + details = [[ +```latex +\NewBibliographyString{key} +``` + +This command declares new localisation strings, i.e. it initializes a +new `key` to be used in the `definitions` of +`\DefineBibliographyStrings`. The `key` argument may also be a +comma-separated list of key names. The keys listed in ?? are defined by +default. +]] + }, + Notecite = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\Notecite[prenote][postnote]{key} +``` + +These commands print the `prenote` and `postnote` arguments but no +citation. This may be useful for authors who incorporate implicit +citations in their writing, only giving information not mentioned before +in the running text, but who still want to take advantage of the +automatic `postnote` formatting and citation tracking. This is a +generic, style-independent citation command. Special citation styles may +provide smarter facilities for the same purpose. The capitalized version +forces capitalization (note that this is only applicable if the note +starts with a command which is sensitive to `biblatex`'s punctuation +tracker). +]] + }, + NumsCheckSetup = { + arguments = {{meta = "code"}}, + details = [[ +```latex +\NumsCheckSetup{code} +``` + +Like `\NumCheckSetup` but only applies to `\ifnumerals` and `\ifpages` +from ?? and their derivative tests. +]] + }, + OnManualCitation = { + arguments = {{meta = "code"}}, + details = [[ +```latex +\OnManualCitation{code} +``` + +Specifies arbitrary `code` required for a partial reset of the citation +style. This hook will be executed every time the `\mancite` command from +?? is used. It is particularly useful in citation styles which replace +repeated citations by abbreviations like <ibidem> or <op. cit.> +which may get ambiguous if automatically generated and manual citations +are mixed. The `\mancite` command also resets the internal <ibidem> +and <idem> trackers of this package. The reset will affect the +`\ifciteibid` and `\ifciteidem` tests discussed in ??. +]] + }, + Parencite = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\Parencite[prenote][postnote]{key} +``` + +These commands use a format similar to `\cite` but enclose the entire +citation in parentheses. The numeric and alphabetic styles use square +brackets instead. `\Parencite` is similar to `\parencite` but +capitalizes the name prefix of the first name in the citation if the +`useprefix` option is enabled, provided that there is a name prefix and +the citation style prints any name at all. +]] + }, + Parencites = { + action = "cite", + details = [[ +```latex +\Parencites(multiprenote)(multipostnote)[prenote][postnote]{key}|...|[prenote][postnote]{key} +``` + +The multicite version of `\parencite` and `\Parencite`, respectively. +]] + }, + Pnotecite = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\Pnotecite[prenote][postnote]{key} +``` + +Similar to `\notecite` but the notes are printed in parentheses. +]] + }, + Pvolcite = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {meta = "volume"}, + {delimiters = {"[", "]"}, meta = "pages", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\Pvolcite[prenote]{volume}[pages]{key} +``` + +Similar to `\volcite` but based on `\parencite`. +]] + }, + Pvolcites = { + action = "cite", + details = [[ +```latex +\Pvolcites(multiprenote)(multipostnote)[prenote]{volume}[pages]{key}|\\...|[prenote]{volume}[pages]{key} +``` + +The multicite version of `\pvolcite` and `\Pvolcite`, respectively. +]] + }, + RequireBibliographyStyle = { + arguments = {{meta = "style"}}, + details = [[ +```latex +\RequireBibliographyStyle{style} +``` + +This command is optional and intended for specialized bibliography +styles built on top of a more generic style. It loads the bibliography +style `style.bbx`. +]] + }, + RequireCitationStyle = { + arguments = {{meta = "style"}}, + details = [[ +```latex +\RequireCitationStyle{style} +``` + +This command is optional and intended for specialized citation styles +built on top of a more generic style. It loads the citation style +`style.cbx`. +]] + }, + ResetDatamodelConstraints = { + details = [[ +```latex +\ResetDatamodelConstraints +``` + +Clear all data model fields Constraints information. +]] + }, + ResetDatamodelFields = { + details = [[ +```latex +\ResetDatamodelFields +``` + +Clear all data model field information. +]] + }, + Rn = { + arguments = {{meta = "integer"}}, + details = [[ +```latex +\Rn{integer} +``` + +Similar to `\RN` but prints a lowercase Roman numeral. The formatting +applied to the numeral may be modified by redefining the macro +`\Rnfont`. +]] + }, + Smartcite = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\Smartcite[prenote][postnote]{key} +``` + +Like `\parencite` in a footnote and like `\footcite` in the body. +]] + }, + Smartcites = { + action = "cite", + details = [[ +```latex +\Smartcites(multiprenote)(multipostnote)[prenote][postnote]{key}|...|[prenote][postnote]{key} +``` + +The multicite version of `\smartcite` and `\Smartcite`, respectively. +]] + }, + Svolcite = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {meta = "volume"}, + {delimiters = {"[", "]"}, meta = "pages", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\Svolcite[prenote]{volume}[pages]{key} +``` + +Similar to `\volcite` but based on `\smartcite`. +]] + }, + Svolcites = { + action = "cite", + details = [[ +```latex +\Svolcites(multiprenote)(multipostnote)[prenote]{volume}[pages]{key}|\\...|[prenote]{volume}[pages]{key} +``` + +The multicite version of `\svolcite` and `\Svolcite`, respectively. +]] + }, + Textcite = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\textcite[prenote][postnote]{key} +\Textcite[prenote][postnote]{key} +``` + +These citation commands are provided by all styles that come with this +package. They are intended for use in the flow of text, replacing the +subject of a sentence. They print the authors or editors followed by a +citation label which is enclosed in parentheses. Depending on the +citation style, the label may be a number, the year of publication, an +abridged version of the title, or something else. The numeric and +alphabetic styles use square brackets instead of parentheses. In the +verbose styles, the label is provided in a footnote. Trailing +punctuation is moved between the author or editor names and the footnote +mark. `\Textcite` is similar to `\textcite` but capitalizes the name +prefix of the first name in the citation if the `useprefix` option is +enabled, provided that there is a name prefix. +]] + }, + Textcites = { + action = "cite", + details = [[ +```latex +\Textcites(multiprenote)(multipostnote)[prenote][postnote]{key}|...|[prenote][postnote]{key} +``` + +The multicite version of `\textcite` and `\Textcite`, respectively. +]] + }, + Tvolcite = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {meta = "volume"}, + {delimiters = {"[", "]"}, meta = "pages", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\Tvolcite[prenote]{volume}[pages]{key} +``` + +Similar to `\volcite` but based on `\textcite`. +]] + }, + Tvolcites = { + action = "cite", + details = [[ +```latex +\Tvolcites(multiprenote)(multipostnote)[prenote]{volume}[pages]{key}|\\...|[prenote]{volume}[pages]{key} +``` + +The multicite version of `\tvolcite` and `\Tvolcite`, respectively. +]] + }, + UndeclareBibstringSets = { + details = [[ +```latex +\UndeclareBibstringSets +``` + +Remove all existing bibliography string sets with +`\UndeclareBibstringSet`. +]] + }, + UndeclareDelimcontextAlias = { + arguments = {{meta = "alias"}}, + details = [[ +```latex +\UndeclareDelimcontextAlias{alias} +``` + +Removes the delimiter context alias declared for `alias`. +]] + }, + UndefineBibliographyExtras = { + arguments = {{meta = "language"}, {meta = "code"}}, + details = [[ +```latex +\UndefineBibliographyExtras{language}{code} +``` + +This command is used to restore the original definition of any commands +modified with `\DefineBibliographyExtras`. If a redefined command is +included in ??, there is no need to restore its previous definition +since these commands are adapted by all language modules anyway. +]] + }, + UneclareBibstringSetFormat = { + arguments = {{meta = "setname"}}, + details = [[ +```latex +\UneclareBibstringSetFormat{setname} +``` + +Remove any bibliography string set format defined for `setname`. +]] + }, + UseBibitemHook = { + details = [[ +```latex +\UseBibitemHook +``` + +Executes the internal hook corresponding to `\AtEveryBibitem`. +]] + }, + UseEveryCiteHook = { + details = [[ +```latex +\UseEveryCiteHook +``` + +Executes the internal hook corresponding to `\AtEveryCite`. +]] + }, + UseEveryMultiCiteHook = { + details = [[ +```latex +\UseEveryMultiCiteHook +``` + +Executes the internal hook corresponding to `\AtMultiEveryCite`. +]] + }, + UseNextCitekeyHook = { + details = [[ +```latex +\UseNextCitekeyHook +``` + +Executes and clears the internal hook corresponding to `\AtNextCitekey`. +]] + }, + UseVolciteHook = { + details = [[ +```latex +\UseVolciteHook +``` + +Executes the internal hook corresponding to `\AtVolcite`. +]] + }, + Volcite = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {meta = "volume"}, + {delimiters = {"[", "]"}, meta = "pages", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\Volcite[prenote]{volume}[pages]{key} +``` + +These commands are similar to `\cite` and `\Cite` but intended for +references to multi-volume works which are cited by volume and page +number. Instead of the `postnote`, they take a mandatory `volume` and an +optional `pages` argument. Since they merely compose the postnote and +pass it to the `\cite` command provided by the citation style as a +`postnote` argument, these commands are style independent. The volume +and pages/text portion are formatted with the macro `\mkvolcitenote` +when they are passed on to the citation command. Additionally they are +made available in the special fields `volcitevolume` and `volcitevolume` +(??) The format of the volume portion is controlled by the field +formatting directive `volcitevolume`, the format of the pages/text +portion is controlled by the field formatting directive `volcitepages` +(??). The delimiter printed between the volume portion and the +pages/text portion may be modified by redefining the macro +`\volcitedelim` (??). +]] + }, + Volcites = { + action = "cite", + details = [[ +```latex +\Volcites(multiprenote)(multipostnote)[prenote]{volume}[pages]{key}|\\...|[prenote]{volume}[pages]{key} +``` + +The multicite version of `\volcite` and `\Volcite`, respectively. +]] + }, + abbrvpenalty = { + details = [[ +```latex +\abbrvpenalty +``` + +This counter, which is used by the localisation modules, holds the +penalty used in short or abbreviated localisation strings. For example, +a linebreak in expressions such as «et al.» or «ed. by» is unfortunate, +but should still be possible to prevent overfull boxes. This counter is +initialized to `\hyphenpenalty` at load-time. The idea is making TeX +treat the whole expression as if it were a single, hyphenatable word as +far as line-breaking is concerned. If you dislike such linebreaks, use a +higher value. If you do not mind them at all, set this counter to zero. +If you want to suppress them unconditionally, set it to <infinite> +(10 000 or higher).[1] + +[1] The default values assigned to `abbrvpenalty`, `lownamepenalty`, and +`highnamepenalty` are deliberately very low to prevent overfull boxes. +This implies that you will hardly notice any effect on line-breaking if +the text is set justified. If you set these counters to 10 000 to +suppress the respective breakpoints, you will notice their effect but +you may also be confronted with overfull boxes. Keep in mind that +line-breaking in the bibliography is often more difficult than in the +body text and that you can not resort to rephrasing a sentence. In some +cases it may be preferable to set the entire bibliography `\raggedright` +to prevent suboptimal linebreaks. In this case, even the fairly low +default penalties will make a visible difference. + +```latex +\abbrvpenalty +``` + +The penalty used by `\addabbrvspace`, `\addabthinspace`, and +`\adddotspace`, see ?? for details. This counter is initialized to +`\hyphenpenalty` at load-time. +]] + }, + addabthinspace = { + details = [[ +```latex +\addabthinspace +``` + +Similar to `\addabbrvspace` but using a thin space. +]] + }, + addbibresource = { + action = "input", + arguments = { + {delimiters = {"[", "]"}, meta = "options", optional = true}, + {meta = "resource"} + }, + details = [[ +```latex +\addbibresource[options]{resource} +``` + +Adds a `resource`, such as a `.bib` file, to the default resource list. +This command is only available in the preamble. It replaces the +`\bibliography` legacy command. Note that files must be specified with +their full name, including the extension. With `biber`, the resource +name can be a BSD-style glob pattern. This only makes sense when +resources refer to files with an absolute or relative path and does not +work when looking for data resources in `biber`s input/output +directories or with resources located by `kpsewhich` etc. When running +on Windows, `biber`will switch to a Windows compatible globbing mode +where backslashes are also useable as path separators and case does not +matter. If the resources contain duplicate entries (that is, duplicate +`entrykey`s), it is backend dependent what then happens. For example, by +default `biber`will ignore further occurrence of `entrykey`s unless its +`–noskipduplicates` options is used. Invoke `\addbibresource` multiple +times to add more resources, for example: + + \addbibresource{bibfile1.bib} + \addbibresource{bibfile2.bib} + \addbibresource[glob]{bibfiles/bibfile*.bib} + \addbibresource[glob]{bibfile-num?.bib} + \addbibresource[glob]{bibfile{1,2,3}.bib} + \addbibresource[location=remote]{https://raw.githubusercontent.com/plk/biblatex/master/bibtex/bib/biblatex/biblatex-examples.bib} + \addbibresource[location=remote,label=lan]{ftp://192.168.1.57/~user/file.bib} + +Since the `resource` string is read in a verbatim-like mode, it may +contain arbitrary characters. The only restriction is that any curly +braces must be balanced. The following `options` are available: + +`bibencoding=<bibencoding>` +This option can be used to override the global `bibencoding` option for +a particular `resource`. + +`label=<identifier>` +Assigns a label to a resource. The `identifier` may be used in place of +the full resource name in the optional argument of `refsection` (see +??). The label is a *unique* identifier for the `resource`, so each +label should only be used once. + +`location=<location>` +The location of the resource. The `location` may be either `local` for +local resources or `remote` for URLs. Remote resources require `biber`. +The protocols HTTP/HTTPS and FTP are supported. The remote URL must be a +fully qualified path to a `bib` file or a URL which returns a `bib` +file. + +`type=<type>` +The type of resource. Currently, the only supported type is `file`. + +`datatype=<datatype>` +The data type (format) of the resource. The following formats are +currently supported: + +bibtex +BibTeX format. + +biblatexml +Experimental XML format for `biblatex`. See ??. + +`glob` +Whether `biber`should glob (expand according to pattern) the datasource +name. There is a global setting for this in `biber`(false by default and +settable to true using the `–glob-datasources` option). This option +allows overriding the `biber`default on a per-resource basis. +]], + filename = "?" + }, + adddot = { + details = [[ +```latex +\adddot +``` + +Adds a period unless it is preceded by any punctuation mark. The purpose +of this command is inserting the dot after an abbreviation. Any dot +inserted this way is recognized as such by the other punctuation +commands. This command may also be used to turn a previously inserted +literal period into an abbreviation dot. +]] + }, + addhighpenspace = { + details = [[ +```latex +\addhighpenspace +``` + +Adds a space penalized by the value of the `highnamepenalty` counter, +see ?? for details. +]] + }, + addhpthinspace = { + details = [[ +```latex +\addhpthinspace +``` + +Similar to `\addhighpenspace` but adds a breakable thin space. +]] + }, + addnbspace = { + details = [[ +```latex +\addnbspace +``` + +Adds a non-breakable interword space. +]] + }, + addnbthinspace = { + details = [[ +```latex +\addnbthinspace +``` + +Adds a non-breakable thin space. This is similar to `\,` and +`\thinspace`. +]] + }, + addperiod = { + details = [[ +```latex +\addperiod +``` + +Adds a period unless it is preceded by an abbreviation dot or any other +punctuation mark. This command may also be used to turn a previously +inserted abbreviation dot into a period, for example at the end of a +sentence. +]] + }, + addquestion = { + details = [[ +```latex +\addquestion +``` + +Adds a question mark unless it is preceded by any punctuation mark +except for an abbreviation dot. +]] + }, + addsectionbib = { + action = "input", + arguments = { + {delimiters = {"[", "]"}, meta = "options", optional = true}, + {meta = "resource"} + }, + details = [[ +```latex +\addsectionbib[options]{resource} +``` + +This command differs from `\addbibresource` in that the resource +`options` are registered but the `resource` not added to any resource +list. This is only required for resources which 1) are given exclusively +in the optional argument of `refsection` (??) and 2) require options +different from the default settings. In this case, `\addsectionbib` is +employed to qualify the `resource` prior to using it by setting the +appropriate `options` in the preamble. The `label` option may be useful +to assign a short name to the resource. +]], + filename = "?" + }, + addsemicolon = { + details = [[ +```latex +\addsemicolon +``` + +Adds a semicolon unless it is preceded by a comma, another semicolon, a +colon, or a period. +]] + }, + addslash = { + details = [[ +```latex +\addslash +``` + +Adds a breakable slash. This command differs from the `\slash` command +in the LaTeX kernel in that a linebreak after the slash is not penalized +at all. +]] + }, + andothersdelim = { + details = [[ +```latex +\andothersdelim +``` + +The delimiter printed before the localisation string <`andothers`> +if a name list like `author` or `editor` is truncated. The default is an +interword space. + +```latex +\andothersdelim +``` + +The delimiter to be printed before the localisation string +<`andothers`> if a name list like `author` or `editor` is +truncated. This command should be incorporated in all formatting +directives for name lists. The default is an interword space. +]] + }, + antecedent = { + arguments = { + { + delimiters = {"[", "]"}, + meta = "quantifier=quantspec", + optional = true + }, + {meta = "fields"} + }, + details = [[ +```latex +\antecedent[quantifier=quantspec]{fields} +``` + +For constraints of `type` <conditional>, specifies a quantified set +of `\constraintfield`s which must be satisfied before the `\consequent` +of the constraint is checked. `quantspec` should have one of the +following values: + +`quantifier={all, one, none}` +Specifies how many of the `\constrainfield`'s inside the `\antecedent` +have to be present to satisfy the antecedent of the conditional +constraint. +]] + }, + assignrefcontextcats = { + arguments = { + {literal = "*", optional = true}, + { + delimiters = {"[", "]"}, + meta = "key=value, ... ", + optional = true + }, + {meta = "category1, category2, ..."} + }, + details = [[ +```latex +\assignrefcontextkeyws[key=value, ... ]{keyword1,keyword2, ...} +\assignrefcontextkeyws*[key=value, ... ]{keyword1,keyword2, ...} +\assignrefcontextcats[key=value, ... ]{category1, category2, ...} +\assignrefcontextcats*[key=value, ... ]{category1, category2, ...} +\assignrefcontextentries[key=value, ... ]{entrykey1, entrykey2, ...} +\assignrefcontextentries*[key=value, ... ]{entrykey1, entrykey2, ...} +\assignrefcontextentries[key=value, ... ]{*} +\assignrefcontextentries*[key=value, ... ]{*} +``` + + +]] + }, + assignrefcontextentries = { + arguments = { + {literal = "*", optional = true}, + { + delimiters = {"[", "]"}, + meta = "key=value, ... ", + optional = true + }, + {meta = "entrykey1, entrykey2, ..."} + }, + details = "$ref:biblatex.sty#/commands/assignrefcontextcats/details" + }, + assignrefcontextkeyws = { + arguments = { + {literal = "*", optional = true}, + { + delimiters = {"[", "]"}, + meta = "key=value, ... ", + optional = true + }, + {meta = "keyword1,keyword2, ..."} + }, + details = "$ref:biblatex.sty#/commands/assignrefcontextcats/details" + }, + authortypedelim = { + details = [[ +```latex +\authortypedelim +``` + +The delimiter printed between the author and the `authortype`. The +default is a comma followed by a space. +]] + }, + autocite = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\autocite[prenote][postnote]{key} +\Autocite[prenote][postnote]{key} +``` + +In contrast to other citation commands, the `\autocite` command does not +only scan ahead for punctuation marks following its last argument to +avoid double punctuation marks, it actually moves them around if +required. For example, with `autocite=footnote`, a trailing punctuation +mark will be moved such that the footnote mark is printed after the +punctuation. `\Autocite` is similar to `\autocite` but capitalizes the +name prefix of the first name in the citation if the `useprefix` option +is enabled, provided that there is a name prefix and the citation style +prints any name at all. +]] + }, + begrelateddelim = { + details = [[ +```latex +\begrelateddelim +``` + +The generic separator before the block of related entries. The default +definition is `\newunitpunct`. +]] + }, + bibbycategory = { + arguments = { + { + delimiters = {"[", "]"}, + meta = "key=value, ... ", + optional = true + } + }, + details = [[ +```latex +\bibbycategory[key=value, ... ] +``` + +This command loops over all bibliography categories. This is equivalent +to giving one `\printbibliography` command for every category but has +the additional benefit of automatically skipping empty categories. The +categories are processed in the order in which they were declared. See +?? for usage examples. The options are a subset of those supported by +`\printbibliography`. Valid options are `env`, `prenote`, `postnote`, +`section`. Note that `heading` is not available with this command. The +name of the current category is automatically used as the heading name. +This is equivalent to passing `heading=category` to `\printbibliography` +and implies that there must be a matching heading definition for every +category. The current bibliography context sorting template is used for +all categories (see ??). +]] + }, + bibbysection = { + arguments = { + { + delimiters = {"[", "]"}, + meta = "key=value, ... ", + optional = true + } + }, + details = [[ +```latex +\bibbysection[key=value, ... ] +``` + +This command automatically loops over all reference sections. This is +equivalent to giving one `\printbibliography` command for every section +but has the additional benefit of automatically skipping sections +without references. Note that `\bibbysection` starts looking for +references in section `1`. It will ignore references given outside of +`refsection` environments since they are assigned to section 0. See ?? +for usage examples. The options are a subset of those supported by +`\printbibliography`. Valid options are `env`, `heading`, `prenote`, +`postnote`. The current bibliography context sorting template is used +for all sections (see ??). +]] + }, + bibcpsstring = { + arguments = { + {delimiters = {"[", "]"}, meta = "wrapper", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\bibcpsstring[wrapper]{key} +``` + +Similar to `\bibsstring` but the term is always capitalized. +]] + }, + bibcpstring = { + arguments = { + {delimiters = {"[", "]"}, meta = "wrapper", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\bibcpstring[wrapper]{key} +``` + +Similar to `\bibstring` but the term is always capitalized. +]] + }, + bibdateeraprefix = { + details = [[ +```latex +\bibdateeraprefix +``` + +The language specific marker which is printed as a prefix to beginning +BCE/BC dates in a date range when the option `dateera` is set to +<astronomical>. Defaults to `\textminus`, if defined and +`\textendash` otherwise. +]] + }, + bibdatesep = { + details = [[ +```latex +\bibdatesep +``` + +The language specific separator used between date components in terse +date formats. Defaults to `\hyphen`. +]] + }, + bibdatetimesep = { + details = [[ +```latex +\bibdatetimesep +``` + +The language specific separator printed between date and time components +when printing time components along with date components (see the +`<datetype>dateusetime` option in ??). Defaults to a space for +non-ISO8601-2 output formats, and 'T' for ISO8601-2 output format. +]] + }, + bibeidpunct = { + details = [[ +```latex +\bibeidpunct +``` + +The separator printed before the `eid` field (similar to +`\bibpagespunct`). The default is a comma plus an interword space. +]] + }, + bibellipsis = { + details = [[ +```latex +\bibellipsis +``` + +An ellipsis symbol with brackets: <\[...\]>. +]] + }, + bibfootnotewrapper = { + arguments = {{meta = "text"}}, + details = [[ +```latex +\bibfootnotewrapper{text} +``` + +An inner wrapper which encloses the `text` argument of `\mkbibfootnote` +and `\mkbibfootnotetext`. For example, `\mkbibfootnote` eventually boils +down to this: + + \footnote{<<\bibfootnotewrapper{>>text<<}>>} + +The wrapper ensures capitalization at the beginning of the note and adds +a period at the end. The default definition is: + + \newcommand{\bibfootnotewrapper}[1]{<<\bibsentence>> #1<<\addperiod>>} + +If you don't want capitalization at the beginning or a period at the end +of the note, do not modify `\mkbibfootnote` but redefine +`\bibfootnotewrapper` instead. +]] + }, + bibhang = { + details = [[ +```latex +\bibhang +``` + +The hanging indentation of the bibliography, if applicable. This length +is initialized to `\parindent` at load-time. If `\parindent` is zero +length for some reason, `\bibhang` will default to `1em`. +]] + }, + bibhyperref = { + arguments = { + {delimiters = {"[", "]"}, meta = "entrykey", optional = true}, + {meta = "text"} + }, + details = [[ +```latex +\bibhyperref[entrykey]{text} +``` + +Transforms `text` into an internal link pointing to `entrykey` in the +bibliography. If `entrykey` is omitted, this command uses the key of the +entry currently being processed. This command is employed to transform +citations into clickable links pointing to the corresponding entry in +the bibliography. The link target is marked automatically by `biblatex`. +If there are multiple bibliographies in a document, the target will be +the first occurence of `entrykey` in one of the bibliographies. If there +are `refsection` environments, the links are local to the environment. +See also the formatting directive `bibhyperref` in ??. +]] + }, + bibhypertarget = { + arguments = {{meta = "name"}, {meta = "text"}}, + details = [[ +```latex +\bibhypertarget{name}{text} +``` + +A wrapper for `hyperref`'s `\hypertarget` command. The `name` is the +name of the anchor, the `text` is arbitrary printable text or code which +serves as an anchor. If there are any `refsection` environments in the +document, the `name` is local to the current environment. If the +`hyperref` package option is disabled or the `hyperref` package has not +been loaded, this command will simply pass on its `text` argument. See +also the formatting directive `bibhypertarget` in ??. +]] + }, + bibindexinithyphendelim = { + details = [[ +```latex +\bibindexinithyphendelim +``` + +Replaces `\bibinithyphendelim` in the index. +]] + }, + bibindexinitperiod = { + details = [[ +```latex +\bibindexinitperiod +``` + +Replaces `\bibinitperiod` in the index. +]] + }, + bibindexnamedelimb = { + details = [[ +```latex +\bibindexnamedelimb +``` + +Replaces `\bibnamedelimb` in the index. +]] + }, + bibindexnamedelimd = { + details = [[ +```latex +\bibindexnamedelimd +``` + +Replaces `\bibnamedelimd` in the index. +]] + }, + bibinithyphendelim = { + details = [[ +```latex +\bibinithyphendelim +``` + +The punctuation inserted automatically by the backend between the +initials of hyphenated name parts, replacing `\bibinitperiod` and +`\bibinitdelim`. The default definition is a period followed by an +unbreakable hyphen. Please refer to ?? for further details. +]] + }, + bibinitperiod = { + details = [[ +```latex +\bibinitperiod +``` + +The punctuation inserted automatically by the backend after all initials +unless `\bibinithyphendelim` applies. The default definition is a period +(`\adddot`). Please refer to ?? for further details. +]] + }, + bibinitsep = { + details = [[ +```latex +\bibinitsep +``` + +Vertical space to be inserted between two entries in the bibliography +whenever an entry starts with a letter which is different from the +initial letter of the previous entry. The default value is zero. Setting +this length to a positive value greater than `bibitemsep` will group the +bibliography alphabetically. Note that `bibitemsep`, `bibnamesep`, and +`bibinitsep` obey the rules for `\addvspace`, that is, when vertical +space introduced by any of these commands immediately follows on from +space introduced by another of them, the resulting total space is equal +to the largest of them. +]] + }, + bibitemsep = { + details = [[ +```latex +\bibitemsep +``` + +The vertical space between the individual entries in the bibliography. +This length is initialized to `\itemsep` at load-time. Note that +`bibitemsep`, `bibnamesep`, and `bibinitsep` obey the rules for +`\addvspace`, that is, when vertical space introduced by any of these +commands immediately follows on from space introduced by another of +them, the resulting total space is equal to the largest of them. + +```latex +\bibitemsep +``` + +The vertical space between the individual entries in the bibliography. +Bibliography styles using `list` environments should set `itemsep` to +`bibitemsep` in the definition of the respective environment. This +length is initialized to `\itemsep` at load-time. +]] + }, + biblcsstring = { + arguments = { + {delimiters = {"[", "]"}, meta = "wrapper", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\biblcsstring[wrapper]{key} +``` + +Similar to `\bibsstring` but the whole term is lowercased. +]] + }, + biblcstring = { + arguments = { + {delimiters = {"[", "]"}, meta = "wrapper", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\biblcstring[wrapper]{key} +``` + +Similar to `\bibstring` but the whole term is lowercased. +]] + }, + bibnamedash = { + details = [[ +```latex +\bibnamedash +``` + +The dash to be used as a replacement for recurrent authors or editors in +the bibliography. The default is an <em> or an <en> dash, +depending on the indentation of the list of references. +]] + }, + bibnamedelimb = { + details = [[ +```latex +\bibnamedelimb +``` + +This delimiter controls the spacing between the elements which make up a +name part. It is inserted automatically by the backend between all name +elements where `\bibnamedelima` does not apply. The default definition +is `\addlowpenspace`, i.e. a space penalized by the value of the +`lownamepenalty` counter (??). Please refer to ?? for further details. +]] + }, + bibnamedelimd = { + details = [[ +```latex +\bibnamedelimd +``` + +This delimiter controls the spacing between name parts. The default name +formats use it between all name parts where `\bibnamedelimc` does not +apply. The default definition is `\addlowpenspace`, i.e. a space +penalized by the value of the `lownamepenalty` counter (??). Please +refer to ?? for further details. +]] + }, + bibncplstring = { + arguments = { + {delimiters = {"[", "]"}, meta = "wrapper", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\bibncplstring[wrapper]{key} +``` + +Similar to `\biblstring` but the term is never capitalized. +]] + }, + bibopenparen = { + details = [[ +```latex +\bibopenparen<text>\bibcloseparen +``` + +Alternative syntax for `\mkbibparens`. This will also work across +groups. Note that `\bibopenparen` and `\bibcloseparen` must always be +balanced. +]] + }, + bibpagespunct = { + details = [[ +```latex +\bibpagespunct +``` + +The separator printed before the `pages` field. The default is a comma +plus an interword space. + +```latex +\bibpagespunct +``` + +The separator to be printed before the `pages` field. Use this separator +instead of `\newunitpunct` at this location. The default is a comma plus +an interword space. +]] + }, + bibrangedash = { + details = [[ +```latex +\bibrangedash +``` + +The language specific dash to be used for ranges of numbers. Defaults to +`\textendash`. +]] + }, + bibsentence = { + details = [[ +```latex +\bibsentence +``` + +This command marks the beginning of a sentence. A localisation string +immediately after this command will be capitalized and the punctuation +tracker is reset, i.e. this command hides all preceding punctuation +marks from the punctuation tracker and enforces capitalization. +]] + }, + bibsetup = { + details = [[ +```latex +\bibsetup +``` + +Arbitrary code to be executed at the beginning of the bibliography, +intended for commands which affect the layout of the bibliography. +]] + }, + bibsstring = { + arguments = { + {delimiters = {"[", "]"}, meta = "wrapper", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\bibsstring[wrapper]{key} +``` + +Similar to `\bibstring` but always prints the short string, ignoring the +`abbreviate` option. +]] + }, + bibstring = { + arguments = { + {delimiters = {"[", "]"}, meta = "wrapper", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\bibstring[wrapper]{key} +``` + +Prints the localisation string `key`, where `key` is an identifier in +lowercase letters (see ??). The string will be capitalized as required, +see ?? for details. Depending on the `abbreviate` package option from +??, `\bibstring` prints the short or the long version of the string. If +localisation strings are nested, i.e. if `\bibstring` is used in another +string, it will behave like `\bibxstring`. If the `wrapper` argument is +given, the string is passed to the `wrapper` for formatting. This is +intended for font commands such as `\emph`. +]] + }, + bibtimesep = { + details = [[ +```latex +\bibtimesep +``` + +The language specific marker which separates time components. Defaults +to a colon. + +```latex +\bibtimesep +``` + +The language specific marker which separates time components. Default to +a colon. +]] + }, + bibtimezonesep = { + details = [[ +```latex +\bibtimezonesep +``` + +The language specific marker which separates an optional time zone +component from a time. Empty by default. +]] + }, + bibuclstring = { + arguments = { + {delimiters = {"[", "]"}, meta = "wrapper", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\bibuclstring[wrapper]{key} +``` + +Similar to `\biblstring` but the whole term is uppercased. +]] + }, + biburlbigbreakpenalty = { + details = [[ +```latex +\biburlbigbreakpenalty +``` + +The `biblatex` version of `url`'s `UrlBigBreakPenalty`. The default +value is `100`. +]] + }, + biburlbigskip = { + details = [[ +```latex +\biburlbigskip +``` + +The `biblatex` version of `Urlmuskip`. This length holds the additional +(stretchable) space inserted around breakable characters in the `\url` +command from the `url` package. The default value is `0mu plus 3mu`. +]] + }, + biburlbreakpenalty = { + details = [[ +```latex +\biburlbreakpenalty +``` + +The `biblatex` version of `url`'s `UrlBreakPenalty`. The default value +is `200`. +]] + }, + biburlucpenalty = { + details = [[ +```latex +\biburlucpenalty +``` + +Similar to `biburlnumpenalty`, except that it will add a breakpoint +after all uppercase letters. +]] + }, + biburlucskip = { + details = [[ +```latex +\biburlucskip +``` + +Similar to `biburlnumskip`, except that it will add space after all +uppercase letters. +]] + }, + bibxlstring = { + arguments = { + {delimiters = {"[", "]"}, meta = "wrapper", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\bibxlstring[wrapper]{key} +``` + +Similar to `\bibxstring` but always uses the long string, ignoring the +`abbreviate` option. +]] + }, + cite = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = "$ref:biblatex.sty#/commands/Cite/details" + }, + citeauthor = { + action = "cite", + arguments = { + {literal = "*", optional = true}, + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = "$ref:biblatex.sty#/commands/Citeauthor/details" + }, + citecount = { + action = "cite", + details = [[ +```latex +\citecount +``` + +The `\citecount` element has a special meaning. It requests a sort based +on the number of times an item was cited. The standard `count` sorting +template uses this to provide a sort in descending order of number of +citations. Note that the option `citecounter` must also be enabled for +this to work. In addition, an additional `biber`run is required in order +to calculate the data for this option correctly and so the typical +invocation sequence for this option is +*latex*$\rightarrow$*biber*$\rightarrow$*latex*$\rightarrow$*latex*$\rightarrow$*biber*$\rightarrow$*latex*. + +```latex +\citecount +``` + +This counter, which is only available in the `loopcode` of a citation +command defined with `\DeclareCiteCommand`, holds the number of the +entry key currently being processed by the `loopcode`. +]] + }, + citecounter = { + action = "cite", + details = [[ +```latex +\citecounter +``` + +This counter indicates how many times the entry currently being +processed is cited in the current reference section. Note that this +feature needs to be enabled explicitly with the package option +`citecounter`. If the option is set to `context`, citations in the body +text and in footnotes are counted separately. In this case, +`citecounter` will hold the value of the context it is used in. +]] + }, + citedate = { + action = "cite", + arguments = { + {literal = "*", optional = true}, + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\citedate*[prenote][postnote]{key} +``` + +This command prints the full date (`date` or `year`). The starred +variant includes the `extradate` information, if any. +]] + }, + citefield = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"}, + {delimiters = {"[", "]"}, meta = "format", optional = true}, + {meta = "field"} + }, + details = [[ +```latex +\citefield[prenote][postnote]{key}[format]{field} +``` + +The `format` is a formatting directive defined with +`\DeclareFieldFormat`. Formatting directives are discussed in ??. If +this optional argument is omitted, this command falls back to the format +`citefield`. The last argument is the name of a `field`, in the sense +explained in ??. +]] + }, + citename = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"}, + {delimiters = {"[", "]"}, meta = "format", optional = true}, + {meta = "name list"} + }, + details = [[ +```latex +\citename[prenote][postnote]{key}[format]{name list} +``` + +The `format` is a formatting directive defined with +`\DeclareNameFormat`. Formatting directives are discussed in ??. If this +optional argument is omitted, this command falls back to the format +`citename`. The last argument is the name of a `name list`, in the sense +explained in ??. +]] + }, + citereset = { + details = [[ +```latex +\citereset +``` + +This command resets the citation style. This may be useful if the style +replaces repeated citations with abbreviations like *ibidem*, *idem*, +*op. cit.*, etc. and you want to force a full citation at the beginning +of a new chapter, section, or some other location. The command executes +a style specific initialization hook defined with the +`\InitializeCitationStyle` command from ??. It also resets the internal +citation trackers of this package. The reset will affect the +`\ifciteseen`, `\ifentryseen`, `\ifciteibid`, and `\ifciteidem` tests +discussed in ??. When used inside a `refsection` environment, the reset +of the citation tracker is local to the current `refsection` +environment. Also see the `citereset` package option in ??. +]] + }, + cites = { + action = "cites", + details = "$ref:biblatex.sty#/commands/Cites/details" + }, + citesetup = { + details = [[ +```latex +\citesetup +``` + +Arbitrary code to be executed at the beginning of each citation command. +]] + }, + citetitle = { + action = "cite", + arguments = { + {literal = "*", optional = true}, + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\citetitle*[prenote][postnote]{key} +``` + +This command prints the title. It will use the abridged title in the +`shorttitle` field, if available. Otherwise it falls back to the full +title found in the `title` field. The starred variant always prints the +full title. +]] + }, + citeyear = { + action = "cite", + arguments = { + {literal = "*", optional = true}, + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\citeyear*[prenote][postnote]{key} +``` + +This command prints the year (`year` field or year component of `date`). +The starred variant includes the `extradate` information, if any. +]] + }, + clearfield = { + arguments = {{meta = "field"}}, + details = [[ +```latex +\clearfield{field} +``` + +Clears the `field` within a local scope. A field cleared this way is +treated as undefined by subsequent data commands. +]] + }, + clearname = { + arguments = {{meta = "name list"}}, + details = [[ +```latex +\clearname{name list} +``` + +Clears the `name list` within a local scope. A list cleared this way is +treated as undefined by subsequent data commands. +]] + }, + command = { + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "keys"} + }, + details = [[ +```latex +\command[prenote][postnote]{keys}<punctuation> +``` + +If the `autopunct` package option from ?? is enabled, they will scan +ahead for any `punctuation` immediately following their last argument. +This is useful to avoid spurious punctuation marks after citations. This +feature is configured with `\DeclareAutoPunctuation`, see ?? for +details. +]] + }, + compcitedelim = { + details = [[ +```latex +\compcitedelim +``` + +Similar to `\multicitedelim`, but used by certain citation styles when +<compressing> multiple citations. The default definition is a comma +plus an interword space. + +```latex +\compcitedelim +``` + +Similar to `\multicitedelim`, but intended for citation styles that +<compress> multiple citations, i.e. print the author only once if +subsequent citations share the same author etc. The default definition +is a comma plus an interword space. +]] + }, + constraintfield = { + arguments = {{meta = "field"}}, + details = [[ +```latex +\constraintfield{field} +``` + +For constraints of `type` <data>, the constraint applies to this +`field`. For constraints of `type` <mandatory>, the entry must +contain this `field`. + +The data model declaration macros may be used multiple times as they +append to the previous definitions. In order to replace, change or +remove existing definitions (such as the default model which is loaded +with `biblatex`), you should reset (clear) the current definition and +then set what you want using the following macros. Typically, these +macros will be the first things in any `biblatex-dm.cfg` file: +]] + }, + constraintfieldsor = { + arguments = {{meta = "fields"}}, + details = [[ +```latex +\constraintfieldsor{fields} +``` + +For constraints of `type` <mandatory>, specifies that an entry must +contain a boolean OR of the `\constraintfield`s. +]] + }, + csfield = { + arguments = {{meta = "field"}}, + details = [[ +```latex +\csfield{field} +``` + +Similar to `\thefield`, but prevents expansion. +]] + }, + currentfield = { + details = [[ +```latex +\currentfield +``` + +The name of the field currently being processed by `\printfield`. This +information is only available locally in field formatting directives. +]] + }, + currentname = { + details = [[ +```latex +\currentname +``` + +The name of the name list currently being processed by `\printnames`. +This information is only available locally in name formatting +directives. +]] + }, + datecircadelim = { + details = [[ +```latex +\datecircadelim +``` + +When formatting dates with the global option `datecirca` enabled, the +delimiter printed after any localised <circa> term. Defaults to +interword space. +]] + }, + datecircaprint = { + details = [[ +```latex +\datecircaprint +``` + +Prints date circa information when the global option `datecirca` is +enabled and the `\ifdatecirca` test is true. By default, prints the +<circa> localised term (??) and the `datecircadelim` delimiter. +]] + }, + datecircaprintiso = { + details = [[ +```latex +\datecircaprintiso +``` + +Prints ISO8601-2 format date circa information when the global option +`datecirca` is enabled and the `\ifdatecirca` test is true. Prints +`\textasciitilde`. +]] + }, + dateeradelim = { + details = [[ +```latex +\dateeradelim +``` + +When formatting dates with the global option `dateera` set, the +delimiter printed before the localisation era term. Defaults to +interword space. +]] + }, + dateeraprint = { + arguments = {{meta = "yearfield"}}, + details = [[ +```latex +\dateeraprint{yearfield} +``` + +Prints date era information when the global option `dateera` is set to +<secular> or <christian>. By default, prints the `dateeradelim` +delimiter and the appropriate localised era term (??). If the +`dateeraauto` option is set, then the passed `yearfield` (which is the +name of a year field such as <year>, <origyear>, <endeventyear> +etc.) is tested to see if its value is earlier than the `dateeraauto` +threshold and if so, then the BCE/CE localisation will be output too. +The default setting for `dateeraauto` is 0 and so only BCE/BC +localisation strings are candidates for output. Detects whether the +start or end year era information is to be printed by looking at the +`yearfield` name passed to it. +]] + }, + dateeraprintpre = { + details = [[ +```latex +\dateeraprintpre +``` + +Prints date era information when the global option `dateera` is set to +<astronomical>. By default, prints `bibdataeraprefix`. Detects +whether the start or end year era information is to be printed by +looking at the `yearfield` name passed to it. +]] + }, + dateuncertainprint = { + details = [[ +```latex +\dateuncertainprint +``` + +Prints date uncertainty information when the global option +`dateuncertain` is enabled and the `\ifdateuncertain` test is true. By +default, prints the language specific `\bibdateuncertain` string (??). +]] + }, + defbibcheck = { + arguments = {{meta = "name"}, {meta = "code"}}, + details = [[ +```latex +\defbibcheck{name}{code} +``` + +Defines the custom bibliography filter `name`, to be used via the +`check` option of `\printbibliography`. `\defbibcheck` is similar in +concept to `\defbibfilter` but much more low-level. Rather than a +high-level expression, the `code` is LaTeX code, much like the code used +in driver definitions, which may perform arbitrary tests to decide +whether or not a given entry is to be printed. The bibliographic data of +the respective entry is available when the `code` is executed. Issuing +the command `\skipentry` in the `code` will cause the current entry to +be skipped. For example, the following filter will only output entries +with an `abstract` field: + + \defbibcheck{<<abstract>>}{% + \iffieldundef{abstract}{<<\skipentry>>}{}} + ... + \printbibliography[<<check=abstract>>] + +The following check will exclude all entries published before the year +2000: + + \defbibcheck{recent}{% + \iffieldint{year} + {\ifnumless{\thefield{year}}{2000} + {\skipentry} + {}} + {\skipentry}} + +See the author guide, in particular ??, for further details. +]] + }, + defbibentryset = { + arguments = {{meta = "key"}, {meta = "key1,key2,key3, ... "}}, + details = [[ +```latex +\defbibentryset{key}{key1,key2,key3, ... } +``` + +The `key` is the entry key of the set, which is used like any other +entry key when referring to the set. The `key` must be unique and it +must not conflict with any other entry key. The second argument is a +comma-separated list of the entry keys which make up the set. +`\defbibentryset` implies the equivalent of a `\nocite` command, i.e. +all sets which are declared are also added to the bibliography. When +declaring the same set more than once, only the first invocation of +`\defbibentryset` will define the set. Subsequent definitions of the +same `key` are ignored and work like `\nocite``key`. Dynamic entry sets +defined in the document body are local to the enclosing `refsection` +environment, if any. Otherwise, they are assigned to reference +section 0. Those defined in the preamble are assigned to reference +section 0. See ?? for further details. +]] + }, + defbibenvironment = { + arguments = { + {meta = "name"}, + {meta = "begin code"}, + {meta = "end code"}, + {meta = "item code"} + }, + details = [[ +```latex +\defbibenvironment{name}{begin code}{end code}{item code} +``` + +This command defines bibliography environments. The `name` is an +identifier passed to the `env` option of `\printbibliography` and +`\printbiblist` when selecting the environment. The `begin code` is +LaTeX code to be executed at the beginning of the environment; the +`end code` is executed at the end of the environment; the `item code` is +code to be executed at the beginning of each entry in the bibliography +or a bibliography list. Here is an example of a definition based on the +standard LaTeX `list` environment: + + \defbibenvironment{bibliography} + {\list{} + {\setlength{\leftmargin}{\bibhang}% + \setlength{\itemindent}{-\leftmargin}% + \setlength{\itemsep}{\bibitemsep}% + \setlength{\parsep}{\bibparsep}}} + {\endlist} + {\item} + +As seen in the above example, usage of `\defbibenvironment` is roughly +similar to `\newenvironment` except that there is an additional +mandatory argument for the `item code`. +]] + }, + defbibfilter = { + arguments = {{meta = "name"}, {meta = "expression"}}, + details = [[ +```latex +\defbibfilter{name}{expression} +``` + +Defines the custom bibliography filter `name`, to be used via the +`filter` option of `\printbibliography`. The `expression` is a complex +test based on the logical operators `and`, `or`, `not`, the group +separator `(...)`, and the following atomic tests: +]] + }, + defbibnote = { + arguments = {{meta = "name"}, {meta = "text"}}, + details = [[ +```latex +\defbibnote{name}{text} +``` + +Defines the bibliography note `name`, to be used via the `prenote` and +`postnote` options of `\printbibliography` and `\printbiblist`. The +`text` may be any arbitrary piece of text, possibly spanning several +paragraphs and containing font declarations. Also see ??. +]] + }, + delimcontext = { + arguments = {{meta = "context"}}, + details = [[ +```latex +\delimcontext{context} +``` + +Set the delimiter context to `context`. This setting is not global so +that delimiter contexts can be nested using the usual LaTeX group +method. +]] + }, + docsvfield = { + arguments = {{meta = "field"}}, + details = [[ +```latex +\docsvfield{field} +``` + +Similar to the `\docsvlist` command from the `etoolbox` package, except +that it takes a field name as its argument. The value of this field is +parsed as a comma-separated list. If the `field` is undefined, this +command expands to an empty string. +]] + }, + enddatecircaprint = { + details = [[ +```latex +\enddatecircaprint +``` + +Prints date circa information when the global option `datecirca` is +enabled and the `\ifenddatecirca` test is true. By default, prints the +<circa> localised term (??) and the `datecircadelim` delimiter. +]] + }, + enddatecircaprintiso = { + details = [[ +```latex +\enddatecircaprintiso +``` + +Prints ISO8601-2 format date circa information when the global option +`datecirca` is enabled and the `\ifenddatecirca` test is true. Prints +`\textasciitilde`. +]] + }, + enddateuncertainprint = { + details = [[ +```latex +\enddateuncertainprint +``` + +Prints date uncertainty information when the global option +`dateuncertain` is enabled and the `\ifenddateuncertain` test is true. +By default, prints the language specific `\bibdateuncertain` string +(??). +]] + }, + entrydata = { + arguments = {{literal = "*", optional = true}, {meta = "key"}, {meta = "code"}}, + details = [[ +```latex +\entrydata{key}{code} +\entrydata*{key}{code} +``` + +Data commands like `\printfield` normally use the data of the entry +currently being processed. You may use `\entrydata` to switch contexts +locally. The `key` is the entry key of the entry to use locally. The +`code` is arbitrary code to be executed in this context. This code will +be executed in a group. See ?? for an example. Note that this command +will automatically switch languages if the `autolang` package option is +enabled. The starred version `\entrydata*` will clone all fields of the +enclosing entry, using field, counter, and other resource names prefixed +with the string <`saved`>. This is useful when comparing two data +sets. For example, inside the `code` argument, the `author` field holds +the author of entry `key` and the author of the enclosing entry is +available as `savedauthor`. The `author` counter holds the number of +names in the `author` field of `key`; the `savedauthor` counter refers +to the author count of the enclosing entry. +]] + }, + entrysetpunct = { + details = [[ +```latex +\entrysetpunct +``` + +The punctuation printed between bibliography subentries of an entry set. +The default definition is a semicolon and a space. +]] + }, + extpostnotedelim = { + details = [[ +```latex +\extpostnotedelim +``` + +The delimiter printed between the citation and the parenthetical +`postnote` argument of a citation command when the postnote occurs +outside of the citation parentheses. In the standard styles, this occurs +when the citation uses the shorthand field of the entry. The default is +an interword space. +]] + }, + field = { + arguments = { + {delimiters = {"[", "]"}, meta = "options", optional = true}, + {meta = "field"} + }, + details = [[ +```latex +\field[options]{field} +``` + +If `field` is non-empty, use it as the current label `\labelelement`, +subject to the options below. Useful values for `field` are typically +the name list type fields, date fields, and title fields. You may also +use the 'citekey' or 'entrykey' pseudo-fields to specify the +citation/entry key as part of the label. Name list fields are treated +specially and when a name list field is specified, the template defined +with `\DeclareLabelalphaNameTemplate` is used to extract parts from the +name which then returns the string that the `\field` option uses. + +`final` +This option marks a `\field` directive as the final one in the +`specification`. If the `field` is non-empty, then this field is used +for the label and the remainder of the `specification` will be ignored. +The short form `final` is equivalent to `final=true`. + +`lowercase` +Forces the label part derived from the field to lowercase. By default, +the case is taken from the field source and not modified. + +`strwidth` +The number of characters of the `field` to use. This setting may be +overridden by an individual name part when extracting characters from a +name. See `\DeclareLabelalphaNameTemplate` below. + +`strside={left, right}` +The side of the string from which to take the `strwidth` number of +characters. This setting may be overridden by an individual name part +when extracting characters from a name. See +`\DeclareLabelalphaNameTemplate` below. + +`padside={left, right}` +Side to pad the label part when using the `padchar` option. Only for use +with fixed-width label strings (`strwidth`). + +`padchar=<character>` +If present, pads the label part on the `padside` side with the specified +character to the length of `strwidth`. Only for use with fixed-width +label strings (`strwidth`). + +`uppercase` +Forces the label part derived from the field to uppercase. By default, +the case is taken from the field source and not modified. + +`varwidth` +Use a variable width, left-side substring of characters from the string +returned for `field`. The length of the string is determined by the +minimum length needed to disambiguate the substring from all other +`field` elements in the same position in the label. For name list +fields, this means that each name substring is disambiguated from all +other name substrings which occur in the same position in the name list +(see examples below). This option overrides `strwidth` if both are used. +The short form `varwidth` is equivalent to `varwidth=true`. For name +list fields, the `\namepart`s with the `pre` option set are prepended to +the string returned from this disambiguation. + +`varwidthnorm` +As `varwidth` but will force the disambiguated substrings for the +`field` to be the same length as the longest disambiguated substring. +This can be used to regularise the format of the labels if desired. This +option overrides `strwidth` if both are used. The short form +`varwidthnorm` is equivalent to `varwidthnorm=true`. + +`varwidthlist` +Alternative method of automatic label disambiguation where the field as +a whole is disambiguated from all other fields in the same label +position. For non-name list fields, this is equivalent to `varwidth`. +For name list fields, names in a name list are not disambiguated from +other names in the same position in their name lists but instead the +entire name list is disambiguated as a whole from other name lists (see +examples below). This option overrides `strwidth` if both are used. The +short form `varwidthlist` is equivalent to `varwidthlist=true`. For name +list fields, the `\namepart`s with the `pre` option set are prepended to +the string returned from this disambiguation. + +`strwidthmax` +When using `varwidth`, this option sets a limit (in number of +characters) on the length of variable width substrings. This option can +be used to regularise the label. + +`strfixedcount` +When using `varwidthnorm`, there must be at least `strfixedcount` +disambiguated substrings with the same, maximal length to trigger the +forcing of all disambiguated substrings to this same maximal length. + +`ifnames=<range>` +Only use this `\field` specification if it is a name list field with a +number of names matching the `ifnames` range value. This allows a +`\labelelement` to be conditionalised on name length (see below). The +range can specified as in the following examples: + + ifnames=3 -> Only apply to name lists containing exactly 3 names + ifnames={2-4} -> Only apply to name lists containing minimum 2 and maximum 4 names + ifnames={-3} -> Only apply to name lists containing at most 3 names + ifnames={2-} -> Only apply to name lists containing at least 2 names + +`names=<range>` +By default, for name list fields, the names used range from the first +name to the `maxalphanames`/`minalphanames` truncation. This option can +be used to override this with an explicit range of names to consider. +The plus <+> sign is a special end of range marker denoting the +truncation point of max/minalphanames. The range separator can be any +number of characters with the Unicode Dash property. For example: + + names=3 -> Use first 3 names in the name list + names={2-3} -> Use second and thirds names only + names={-3} -> Same as 1-3 + names={2-} -> Use all names starting with the second name (ignoring max/minalphanames truncation) + names={2-+} -> Use all names starting with the second name (respecting max/minalphanames truncation) + +`namessep=<string>` +An arbitrary string separator to put between names in a namelist. + +`noalphaothers` +By default, `\labelalphaothers` is appended to label parts derived from +name lists if there are more names in the list than are shown in the +label part. This option can be used to disable the default behaviour. + +```latex +\field[key=value, ... ]{field} +``` + +The `\field` element adds a `field` to the sorting specification. If the +`field` is undefined, the element is skipped. The `\field` command +supports the following optional arguments: + +`padside={left, right}` +Pads a field on the `left` or `right` side using `padchar` so that its +width is `padwidth`. If no padding option is set, no padding is done at +all. If any padding option is specified, then padding is performed and +the missing options are assigned built-in default values. If padding and +substring matching are both specified, the substring match is performed +first. + +`padwidth` +The target width in characters. + +`padchar=<character>` +The character to be used when padding the field. + +`strside={left, right}` +Performs a substring match on the `left` or `right` side of the field. +The number of characters to match is specified by the corresponding +`strwidth` option. If no substring option is set, no substring matching +is performed at all. If any substring option is specified, then +substring matching is performed and the missing options are assigned +built-in default values. If padding and substring matching are both +specified, the substring match is performed first. + +`strwidth` +The number of characters to match. +]] + }, + fieldhascomputableequivalent = { + arguments = {{meta = "field"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\fieldhascomputableequivalent{field}{true}{false} +``` + +Similar to `\hascomputableequivalent`, but uses the value of a `field` +rather than a literal string in the test. If the `field` is undefined, +it executes `false`. +]] + }, + filteror = { + arguments = {{meta = "type"}, {meta = "filters"}}, + details = [[ +```latex +\filteror{type}{filters} +``` + +A wrapper around one or more `\filter` commands specifying that they +form a disjunctive set, i.e. any one of the `filters` must be satisfied. +]] + }, + finalandsemicolon = { + details = [[ +```latex +\finalandsemicolon +``` + +Prints the semicolon to be inserted before the final <and> in a list +of lists, if applicable in the respective language. Here is an example: + + Goossens, Mittelbach, and Samarin; Bertram and Wenworth<<;>> and Knuth + +`\finalandsemicolon` is the semicolon before the word <and>. See also +`\textcitedelim` in ??. + +```latex +\finalandsemicolon +``` + +Prints the semicolon to be inserted before the final <and> in an +enumeration, if applicable in the respective language. +]] + }, + finallistdelim = { + details = [[ +```latex +\finallistdelim +``` + +The delimiter printed instead of `\multilistdelim` before the final item +in a literal list. The default is the localised term <and>, separated +by interword spaces. See `\finalnamedelim` for further explanation. + +```latex +\finallistdelim +``` + +Use this command instead of `\multilistdelim` before the final item in a +literal list. The default is the localised term <and>, separated by +interword spaces. +]] + }, + finalnamedelim = { + details = [[ +```latex +\finalnamedelim +``` + +The delimiter printed instead of `\multinamedelim` before the final name +in a name list. The default is the localised term <and>, separated by +interword spaces. Here is an example: + + Michel Goossens<<,>> Frank Mittelbach <<and>> Alexander Samarin + Edward Jones <<and>> Joe Williams + +The comma in the first example is the `\multinamedelim` whereas the +string <and> in both examples is the `\finalnamedelim`. See also +`\finalandcomma` in ??. + +```latex +\finalnamedelim +``` + +Use this command instead of `\multinamedelim` before the final name in a +name list. The default is the localised term <and>, separated by +interword spaces. +]] + }, + finentry = { + details = [[ +```latex +\finentry +``` + +Inserts `\finentrypunct`. This command should be used at the very end of +every bibliography entry. +]] + }, + footcitetext = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\footcitetext[prenote][postnote]{key} +``` + +These command use a format similar to `\cite` but put the entire +citation in a footnote and add a period at the end. In the footnote, +they automatically capitalize the name prefix of the first name if the +`useprefix` option is enabled, provided that there is a name prefix and +the citation style prints any name at all. `\footcitetext` differs from +`\footcite` in that it uses `\footnotetext` instead of `\footnote`. +]] + }, + footcitetexts = { + action = "cite", + details = [[ +```latex +\footcitetexts(multiprenote)(multipostnote)[prenote][postnote]{key}|...|[prenote][postnote]{key} +``` + +The multicite version of `\footcite` and `\footcitetext`, respectively. +]] + }, + footfullcite = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\footfullcite[prenote][postnote]{key} +``` + +Similar to `\fullcite` but puts the entire citation in a footnote and +adds a period at the end. +]] + }, + forceY = { + details = [[ +```latex +\forceY +``` + +Similar to `\forceE` but enforces <y>. +]] + }, + forcezerosy = { + arguments = {{meta = "integer"}}, + details = [[ +```latex +\forcezerosy{integer} +``` + +This command adds zeros to a year (or any number supposed to be +4-digits). It is intended for date formatting and ordinals. The argument +is expanded with `\protected@edef` before it is processed. +]] + }, + ftvolcite = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {meta = "volume"}, + {delimiters = {"[", "]"}, meta = "pages", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\ftvolcite[prenote]{volume}[pages]{key} +``` + +Similar to `\volcite` but based on `\footcite` and `\footcitetext`, +respectively. +]] + }, + getfieldannotation = { + arguments = { + {delimiters = {"[", "]"}, meta = "field", optional = true}, + { + delimiters = {"[", "]"}, + meta = "annotationname", + optional = true + } + }, + details = [[ +```latex +\getfieldannotation[field][annotationname] +``` + +Retrieves any literal annotation for the field `field`. If +`annotationname` is not given, then the annotation named <default> is +assumed (this is the name given to annotations defined without an +explicit name). If `field` is not given, the current data field as +indicated by `\currentfield`, `\currentlist` or `\currentname` (see ??) +is assumed. Of course, this is only possible if these commands are +defined, that is, inside formatting directives. +]] + }, + getpartannotation = { + arguments = { + {delimiters = {"[", "]"}, meta = "field", optional = true}, + { + delimiters = {"[", "]"}, + meta = "annotationname", + optional = true + }, + {delimiters = {"[", "]"}, meta = "item", optional = true}, + {meta = "part"} + }, + details = [[ +```latex +\getpartannotation[field][annotationname][item]{part} +``` + +Retrieves any literal annotation for the part `part`. If +`annotationname` is not given, then the annotation named <default> is +assumed (this is the name given to annotations defined without an +explicit name). The two optional arguments `field` and `item` can be +inferred as in `\getitemannotation`. The parameter `part` can never be +inferred and is therefore a mandatory argument. + +Date fields are special and handled in a context where `\currentfield` +is not accessible. Thus there is a fourth command to access literal +annotations for dates. +]] + }, + hasfieldannotation = { + arguments = { + {delimiters = {"[", "]"}, meta = "field", optional = true}, + { + delimiters = {"[", "]"}, + meta = "annotationname", + optional = true + }, + {meta = "true"}, + {meta = "false"} + }, + details = [[ +```latex +\hasfieldannotation[field][annotationname]{true}{false} +``` + +Executes `true` if the data field `field` has a literal annotation +`annotationname` defined and false otherwise. If `annotationname` is not +given, then the annotation named <default> is assumed (this is the +name given to annotations defined without an explicit name). If `field` +is not given, the current data field as indicated by `\currentfield`, +`\currentlist` or `\currentname` (see ??) is assumed. Of course, this is +only possible if these commands are defined, that is, inside formatting +directives. +]] + }, + haspartannotation = { + arguments = { + {delimiters = {"[", "]"}, meta = "field", optional = true}, + { + delimiters = {"[", "]"}, + meta = "annotationname", + optional = true + }, + {delimiters = {"[", "]"}, meta = "item", optional = true}, + {meta = "part"}, + {meta = "true"}, + {meta = "false"} + }, + details = [[ +```latex +\haspartannotation[field][annotationname][item]{part}{true}{false} +``` + +Executes `true` if the part named `part` in the item `item` in the data +field `field` has a literal annotation `annotationname` defined and +false otherwise. If `annotationname` is not given, then the annotation +named <default> is assumed (this is the name given to annotations +defined without an explicit name). The two optional arguments `field` +and `item` can be inferred as in `\ifitemannotation`. The parameter +`part` can never be inferred and is therefore a mandatory argument. + +Date fields are special and handled in a context where `\currentfield` +is not accessible. Thus there is a fourth command to test the existence +of annotations for dates. +]] + }, + hyphenate = { + details = [[ +```latex +\hyphenate +``` + +A conditional hyphen. In contrast to the standard `\-` command, this one +allows hyphenation in the rest of the word. It is similar to the `"-` +shorthand provided by some language modules of the `babel`/`polyglossia` +packages. +]] + }, + ifbibindex = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifbibindex{true}{false} +``` + +Expands to `true` or `false` depending on the `indexing` option from ??. +]] + }, + ifbibxstring = { + arguments = {{meta = "string"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifbibxstring{string}{true}{false} +``` + +Similar to `\ifbibstring`, but the `string` is expanded. +]] + }, + ifboolexpr = { + arguments = {{meta = "expression"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifboolexpr{expression}{true}{false} +``` + +`etoolbox` command which allows for complex tests with boolean operators +and grouping: + + {} + \ifboolexpr{ ( + test {\ifnameundef{editor}} + and + not test {\iflistundef{location}} + ) + or test {\iffieldundef{year}} + } + {...} + {...} +]] + }, + ifcapital = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifcapital{true}{false} +``` + +Executes `true` if `biblatex`'s punctuation tracker would capitalize a +localisation string at the current location, and `false` otherwise. This +command is robust. It may be useful for conditional capitalization of +certain parts of a name in a formatting directive. +]] + }, + ifciteibid = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifciteibid{true}{false} +``` + +Expands to `true` if the entry currently being processed is the same as +the last one, and to `false` otherwise. This command is intended for use +in citation styles. If there are any `refsection` environments in the +document, the tracking is local to these environments. Note that the +<ibidem> tracker needs to be enabled explicitly with the package +option `ibidtracker`. The behavior of this test depends on the mode the +tracker is operating in, see ?? for details. If the tracker is disabled, +the test always yields `false`. Also see the `\citetrackertrue` and +`\citetrackerfalse` switches in ??. +]] + }, + ifcurrentlist = { + arguments = {{meta = "literal list"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifcurrentlist{literal list}{true}{false} +``` + +Executes `true` if the current list is `literal list`, and `false` +otherwise. This command is robust. It is intended for use in list +formatting directives and always executes `false` when used in any other +context. +]] + }, + ifdatehastime = { + arguments = {{meta = "datetype"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifdatehastime{datetype}{true}{false} +``` + +Expands to `true` if the `datetype`date is defined, has a time component +and `<datetype>dateusetime` is true, and to false otherwise. +]] + }, + ifdaterangesequal = { + arguments = { + {meta = "datetype1"}, + {meta = "datetype2"}, + {meta = "true"}, + {meta = "false"} + }, + details = [[ +```latex +\ifdaterangesequal{datetype1}{datetype2}{true}{false} +``` + +Expands to `true` if the two date ranges---that is the start and the end +date---`datetype1` and `datetype2` are the same. +]] + }, + ifdateunknown = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifdateunknown{true}{false} +``` + +As `\if<datetype>dateunknown` but for use in `\mkbibdate*` formatting +commands (??) inside which the appropriate `\if<datetype>dateunknown` +command is aliased to this command. +]] + }, + ifdateyearsequal = { + arguments = { + {meta = "datetype1"}, + {meta = "datetype2"}, + {meta = "true"}, + {meta = "false"} + }, + details = [[ +```latex +\ifdateyearsequal{datetype1}{datetype2}{true}{false} +``` + +Expands to `true` if the two dates `datetype1` and `datetype2` have the +same year and era. Since the sign of the date is saved in the era field, +years should be compared using this command to avoid confusion when the +two years have opposite signs +]] + }, + ifenddateuncertain = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifenddateuncertain{true}{false} +``` + +As `\ifend<datetype>dateuncertain` but for use in `\mkbibdate*` +formatting commands (??) inside which the appropriate +`\ifend<datetype>dateuncertain` command is aliased to this command. +]] + }, + ifentrycategory = { + arguments = { + {meta = "entrykey"}, + {meta = "category"}, + {meta = "true"}, + {meta = "false"} + }, + details = [[ +```latex +\ifentryseen{entrykey}{true}{false} +\ifentryinbib{entrykey}{true}{false} +\ifentrycategory{entrykey}{category}{true}{false} +\ifentrykeyword{entrykey}{keyword}{true}{false} +``` + + + +```latex +\ifentrycategory{entrykey}{category}{true}{false} +``` + +A variant of `\ifcategory` which takes an entry key as its first +argument. This is useful for testing an entry other than the one +currently processed. A user-facing version of this command is available +for use in documents see ?? +]] + }, + ifentryinbib = { + arguments = {{meta = "entrykey"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifentryseen{entrykey}{true}{false} +\ifentryinbib{entrykey}{true}{false} +\ifentrycategory{entrykey}{category}{true}{false} +\ifentrykeyword{entrykey}{keyword}{true}{false} +``` + + +]] + }, + ifentrykeyword = { + arguments = { + {meta = "entrykey"}, + {meta = "keyword"}, + {meta = "true"}, + {meta = "false"} + }, + details = [[ +```latex +\ifentryseen{entrykey}{true}{false} +\ifentryinbib{entrykey}{true}{false} +\ifentrycategory{entrykey}{category}{true}{false} +\ifentrykeyword{entrykey}{keyword}{true}{false} +``` + + + +```latex +\ifentrykeyword{entrykey}{keyword}{true}{false} +``` + +A variant of `\ifkeyword` which takes an entry key as its first +argument. This is useful for testing an entry other than the one +currently processed. A user-facing version of this command is available +for use in documents see ??. +]] + }, + ifentryseen = { + arguments = {{meta = "entrykey"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifentryseen{entrykey}{true}{false} +\ifentryinbib{entrykey}{true}{false} +\ifentrycategory{entrykey}{category}{true}{false} +\ifentrykeyword{entrykey}{keyword}{true}{false} +``` + + + +```latex +\ifentryseen{entrykey}{true}{false} +``` + +A variant of `\ifciteseen` which takes an entry key as its first +argument. Since the `entrykey` is expanded prior to performing the test, +it is possible to test for entry keys in a field such as `xref`: + + \ifentryseen{<<\thefield{xref}>>}{true}{false} + +Apart from the additional argument, `\ifentryseen` behaves like +`\ifciteseen`. A user-facing version of this command is available for +use in documents see ??. +]] + }, + ifentrytype = { + arguments = {{meta = "type"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifentrytype{type}{true}{false} +``` + +Executes `true` if the entry type of the entry currently being processed +is `type`, and `false` otherwise. +]] + }, + iffieldannotation = { + arguments = { + {delimiters = {"[", "]"}, meta = "field", optional = true}, + { + delimiters = {"[", "]"}, + meta = "annotationname", + optional = true + }, + {meta = "annotation"}, + {meta = "true"}, + {meta = "false"} + }, + details = [[ +```latex +\iffieldannotation[field][annotationname]{annotation}{true}{false} +``` + +Executes `true` if the data field `field` has an annotation `annotation` +for the annotation called `annotationname` and false otherwise. If +`annotationname` is not given, then the annotation named <default> is +assumed (this is the name given to annotations defined without an +explicit name). If `field` is not given, the current data field as +indicated by `\currentfield`, `\currentlist` or `\currentname` (see ??) +is assumed. Of course, this is only possible if these commands are +defined, that is, inside formatting directives. +]] + }, + iffieldequalcs = { + arguments = { + {meta = "field"}, + {meta = "csname"}, + {meta = "true"}, + {meta = "false"} + }, + details = [[ +```latex +\iffieldequalcs{field}{csname}{true}{false} +``` + +Similar to `\iffieldequals` but takes the control sequence name `csname` +(without a leading backslash) as an argument, rather than a macro name. +]] + }, + iffieldformatundef = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "name"}, + {meta = "true"}, + {meta = "false"} + }, + details = [[ +```latex +\iffieldformatundef[entry type]{name}{true}{false} +\iflistformatundef[entry type]{name}{true}{false} +\ifnameformatundef[entry type]{name}{true}{false} +\iflistwrapperformatundef[entry type]{name}{true}{false} +\ifnamewrapperformatundef[entry type]{name}{true}{false} +``` + +Expands to `true` if the formatting directive `format` is undefined, and +to `false` otherwise. +]] + }, + iffieldnum = { + arguments = {{meta = "field"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\iffieldnum{field}{true}{false} +``` + +Similar to `\ifnumeral`, but uses the value of a `field` rather than a +literal string in the test. If the `field` is undefined, it executes +`false`. +]] + }, + iffieldpages = { + arguments = {{meta = "field"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\iffieldpages{field}{true}{false} +``` + +Similar to `\ifpages`, but uses the value of a `field` rather than a +literal string in the test. If the `field` is undefined, it executes +`false`. +]] + }, + iffieldplusstringbibstring = { + arguments = { + {meta = "field"}, + {meta = "string"}, + {meta = "true"}, + {meta = "false"} + }, + details = [[ +```latex +\iffieldplusstringbibstring{field}{string}{true}{false} +``` + +Similar to `\iffieldbibstring`, but appends `string` to the value of +`field` and checks if the resulting string is a known localisation key. +Expands to `false` if `field` is undefined. +]] + }, + iffieldsequal = { + arguments = { + {meta = "field 1"}, + {meta = "field 2"}, + {meta = "true"}, + {meta = "false"} + }, + details = [[ +```latex +\iffieldsequal{field 1}{field 2}{true}{false} +``` + +Expands to `true` if the values of `field 1` and `field 2` are equal, +and to `false` otherwise. +]] + }, + iffieldxref = { + arguments = {{meta = "field"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\iffieldxref{field}{true}{false} +``` + +If the `crossref`/`xref` field of an entry is defined, this command +checks if the `field` is related to the cross-referenced parent entry. +It executes `true` if the `field` of the child entry is equal to the +corresponding `field` of the parent entry, and `false` otherwise. If the +`crossref`/`xref` field is undefined, it always executes `false`. This +command is robust. See the description of the `crossref` and `xref` +fields in ?? as well as ?? for further information concerning +cross-referencing. +]] + }, + iffirstcitekey = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\iffirstcitekey{true}{false} +``` + +Executes `true` if the entry currently being processed is the first one +in the citation list, and `false` otherwise. This command relies on the +`citecount`, `citetotal`, `multicitecount` and `multicitetotal` counters +(??) and thus is intended for use only in the `loopcode` of a citation +command defined with `\DeclareCiteCommand`. +]] + }, + iffirstonpage = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\iffirstonpage{true}{false} +``` + +The behavior of this command is responsive to the package option +`pagetracker`. If the option is set to `page`, it expands to `true` if +the current item is the first one on the page, and to `false` otherwise. +If the option is set to `spread`, it expands to `true` if the current +item is the first one on the double-page spread, and to `false` +otherwise. If the page tracker is disabled, this test always yields +`false`. Depending on the context, the <item> may be a citation or an +entry in the bibliography or a bibliography list. Note that this test +distinguishes between body text and footnotes. For example, if used in +the first footnote on a page, it will expand to `true` even if there is +a citation in the body text prior to the footnote. Also see the +`\pagetrackertrue` and `\pagetrackerfalse` switches in ??. +]] + }, + ifinteger = { + arguments = {{meta = "string"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifinteger{string}{true}{false} +``` + +Executes `true` if the `string` is a positive integer, and `false` +otherwise. This command is robust. +]] + }, + ifiscomputable = { + arguments = {{meta = "string"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifiscomputable{string}{true}{false} +``` + +Returns `true` if `\ifinteger` or `\hascomputableequivalent` retrurns +`true` on `string` and `false` otherwise. +]] + }, + ifkomabibtotoc = { + arguments = {{meta = "true"}, {meta = "false"}}, + deprecated = true, + details = [[ +```latex +\ifkomabibtotoc{true}{false} +``` + +Expands to `true` if the class would add the bibliography to the table +of contents, and to `false` otherwise. This test is deprecated. +]] + }, + iflabelalphanametemplatename = { + arguments = {{meta = "string"}, {meta = "true"}, {meta = "false"}}, + details = [=[ +```latex +\iflabelalphanametemplatename{string}{true}{false} +``` + +Expands to `true` if the `string` is equal to the current in scope +alphabetic label name template name (see [\[aut:ctm:srt\]][1]), and to +`false` otherwise. + + [1]: #aut:ctm:srt +]=] + }, + iflabeldateisdate = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\iflabeldateisdate{true}{false} +``` + +Expands to `true` if labeldate is defined and was obtained from date, +and to `false` otherwise. +]] + }, + iflistequals = { + arguments = { + {meta = "literal list"}, + {meta = "macro"}, + {meta = "true"}, + {meta = "false"} + }, + details = [[ +```latex +\iflistequals{literal list}{macro}{true}{false} +``` + +Expands to `true` if the value of the `literal list` is equal to the +definition of `macro`, and to `false` otherwise. +]] + }, + iflistformatundef = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "name"}, + {meta = "true"}, + {meta = "false"} + }, + details = "$ref:biblatex.sty#/commands/iffieldformatundef/details" + }, + iflistundef = { + arguments = {{meta = "literal list"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\iflistundef{literal list}{true}{false} +``` + +Expands to `true` if the `literal list` is undefined, and to `false` +otherwise. +]] + }, + iflistwrapperformatundef = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "name"}, + {meta = "true"}, + {meta = "false"} + }, + details = "$ref:biblatex.sty#/commands/iffieldformatundef/details" + }, + ifmemoirbibintoc = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifmemoirbibintoc{true}{false} +``` + +Expands to `true` or `false`, depending on `memoir`'s `\bibintoc` and +`\nobibintoc` switches. This is a LaTeX frontend to `memoir`'s +`\ifnobibintoc` test. Note that the logic of the test is reversed. +]] + }, + ifmorenames = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifmorenames{true}{false} +``` + +Expands to `true` if the current name list has been or will be +truncated, and to `false` otherwise. This command is intended for use in +formatting directives for name lists. It will always expand to `false` +when used elsewhere. This command performs the equivalent of an +`\ifandothers` test for the current list. If this test is negative, it +also checks if the `listtotal` counter is larger than `liststop`. This +command may be used in a formatting directive to decide if a note such +as «and others» or «et al.» is to be printed at the end of the list. +Note that you still need to check whether you are in the middle or at +the end of the list, i.e. whether `listcount` is smaller than or equal +to `liststop`, see ?? for details. +]] + }, + ifnameequalcs = { + arguments = { + {meta = "name list"}, + {meta = "csname"}, + {meta = "true"}, + {meta = "false"} + }, + details = [[ +```latex +\ifnameequalcs{name list}{csname}{true}{false} +``` + +Similar to `\ifnameequals` but takes the control sequence name `csname` +(without a leading backslash) as an argument, rather than a macro name. +]] + }, + ifnameformatundef = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "name"}, + {meta = "true"}, + {meta = "false"} + }, + details = "$ref:biblatex.sty#/commands/iffieldformatundef/details" + }, + ifnamesequal = { + arguments = { + {meta = "name list 1"}, + {meta = "name list 2"}, + {meta = "true"}, + {meta = "false"} + }, + details = [[ +```latex +\ifnamesequal{name list 1}{name list 2}{true}{false} +``` + +Expands to `true` if the values of `name list 1` and `name list 2` are +equal, and to `false` otherwise. +]] + }, + ifnamewrapperformatundef = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "name"}, + {meta = "true"}, + {meta = "false"} + }, + details = "$ref:biblatex.sty#/commands/iffieldformatundef/details" + }, + ifnamexref = { + arguments = {{meta = "name list"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifnamexref{name list}{true}{false} +``` + +Similar to `\iffieldxref` but checks if a `name list` is related to the +cross-referenced parent entry. See the description of the `crossref` and +`xref` fields in ?? as well as ?? for further information concerning +cross-referencing. +]] + }, + ifnatbibmode = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifnatbibmode{true}{false} +``` + +Expands to `true` or `false` depending on the `natbib` option from ??. +]] + }, + ifnocite = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifnocite{true}{false} +``` + +Expands to `true` if the entry was *only* included in the `.bbl` via +`\nocite`. That is, returns `false` if an entry was both `\nocite`'d and +`\cite`'d. +]] + }, + ifnumeral = { + arguments = {{meta = "string"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifnumeral{string}{true}{false} +``` + +Executes `true` if the `string` is an Arabic or Roman numeral, and +`false` otherwise. This command is robust. See also `\DeclareNumChars` +and `\NumCheckSetup` in ??. +]] + }, + ifopcit = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifopcit{true}{false} +``` + +This command is similar to `\ifciteibid` except that it expands to +`true` if the entry currently being processed is the same as the last +one *by this author or editor*. Note that the <opcit> tracker needs +to be enabled explicitly with the package option `opcittracker`. The +behavior of this test depends on the mode the tracker is operating in, +see ?? for details. If the tracker is disabled, the test always yields +`false`. Also see the `\citetrackertrue` and `\citetrackerfalse` +switches in ??. +]] + }, + ifpages = { + arguments = {{meta = "string"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifpages{string}{true}{false} +``` + +Similar to `\ifnumerals`, but also considers `\DeclarePageCommands` and +`\PagesCheckSetup` from ??. +]] + }, + ifpartannotation = { + arguments = { + {delimiters = {"[", "]"}, meta = "field", optional = true}, + { + delimiters = {"[", "]"}, + meta = "annotationname", + optional = true + }, + {delimiters = {"[", "]"}, meta = "item", optional = true}, + {meta = "part"}, + {meta = "annotation"}, + {meta = "true"}, + {meta = "false"} + }, + details = [[ +```latex +\ifpartannotation[field][annotationname][item]{part}{annotation}{true}{false} +``` + +Executes `true` if the part named `part` in item `item` in the data +field `field` has an annotation `annotation` and false otherwise. If +`annotationname` is not given, then the annotation named <default> is +assumed (this is the name given to annotations defined without an +explicit name). The two optional arguments `field` and `item` can be +inferred as in `\ifitemannotation`. The parameter `part` can never be +inferred and is therefore a mandatory argument. + +Date fields are special and handled in a context where `\currentfield` +is not accessible. Thus there is a fourth command to test annotations +for dates. +]] + }, + ifpunct = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifpunct{true}{false} +``` + +Executes `true` if preceded by any punctuation mark except for an +abbreviation dot, and `false` otherwise. +]] + }, + ifpunctmark = { + arguments = {{meta = "character"}, {meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifpunctmark{character}{true}{false} +``` + +Executes `true` if preceded by the punctuation mark `character`, and +`false` otherwise. The `character` may be a comma, a semicolon, a colon, +a period, an exclamation mark, a question mark, or an asterisk. Note +that a period denotes an end-of-sentence period. Use the asterisk to +test for the dot after an abbreviation. If this command is used in a +formatting directive for name lists, i.e. in the argument to +`\DeclareNameFormat`, the `character` may also be an apostrophe. +]] + }, + ifsortingnamekeytemplatename = { + arguments = {{meta = "string"}, {meta = "true"}, {meta = "false"}}, + details = [=[ +```latex +\ifsortingnamekeytemplatename{string}{true}{false} +``` + +Expands to `true` if the `string` is equal to the current in scope +sorting name key template name (see [\[aut:ctm:srt\]][1]), and to +`false` otherwise. + + [1]: #aut:ctm:srt +]=] + }, + ifuniquebaretitle = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifuniquebaretitle{true}{false} +``` + +Expands to `true` if `labelname` is empty and there is only one work +with the title `labeltitle` and to `false` otherwise. If `labeltitle` is +not set for an entry, this will always expand to `false`. Note that this +feature needs to be enabled explicitly with the package option +`uniquebaretitle`. +]] + }, + ifuniqueprimaryauthor = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifuniqueprimaryauthor{true}{false} +``` + +Expands to `true` if the primary (first) author name of `labelname` is +unique in the bibliography list and to `false` otherwise. This +effectively answers the question <is there more than one author with +the same base name>. The base name parts are defined by +`\DeclareUniquenameTemplate` see ??. This is required by some styles +(e.g. APA) which mandates primary author disambiguation only and only if +there are (different) primary authors with the same family name. If +`labelname` is not set for an entry, this will always expand to `false`. +Note that this feature needs to be enabled explicitly with the package +option `uniqueprimaryauthor`. +]] + }, + ifuseeditor = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifuseeditor{true}{false} +``` + +This is just a particular case of the `\ifuse<name>` macro below but is +mentioned here as `editor` is part of the default data model. Expands to +`true` if the `useeditor` option is enabled (either globally or for the +current entry), and `false` otherwise. See ?? for details on this +option. +]] + }, + ifuseprefix = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifuseprefix{true}{false} +``` + +Expands to `true` if the `useprefix` option is enabled (either globally +or for the current entry), and `false` otherwise. See ?? for details on +this option. +]] + }, + ifvolcite = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifvolcite{true}{false} +``` + +Expands to `true` when located in `\volcite` or a related citation +command (??), and to `false` otherwise. +]] + }, + ifxrefsource = { + arguments = {{meta = "true"}, {meta = "false"}}, + details = [[ +```latex +\ifxrefsource{true}{false} +``` + +Expands to `true` if the entry was inclued in the `.bbl` due to being +referenced more than `minxrefs` times and false otherwise. See ??. Also +expands to false if the entry was directly cited. +]] + }, + indexlist = { + arguments = { + {delimiters = {"[", "]"}, meta = "format", optional = true}, + {delimiters = {"[", "]"}, meta = "start--stop", optional = true}, + {meta = "literal list"} + }, + details = [[ +```latex +\indexlist[format][start--stop]{literal list} +``` + +This command is similar to `\printlist` except that the items in the +list are not printed but added to the index using the formatting +directive `format`, as defined with `\DeclareIndexListFormat`. If a +type-specific `format` has been declared, the type-specific formatting +directive takes precedence over the generic one. If the `literal list` +is undefined, this command does nothing. If the `format` is omitted, +`\indexlist` tries using the name of the list as a format name. In this +case, any type-specific formatting directive will also take precedence +over the generic one. If all of these formats are undefined, it falls +back to `default` as a last resort. +]] + }, + instcount = { + details = [[ +```latex +\instcount +``` + +This counter is incremented by `biblatex`for every citation as well as +for every entry in the bibliography and bibliography lists. The value of +this counter uniquely identifies a single instance of a reference in the +document. +]] + }, + labelalphawidth = { + details = [[ +```latex +\labelalphawidth +``` + +This length register indicates the width of the widest `labelalpha`. +Alphabetic bibliography styles should incorporate this length in the +definition of the bibliography environment. +]] + }, + letbibmacro = { + arguments = { + {literal = "*", optional = true}, + {meta = "alias"}, + {meta = "name"} + }, + details = [[ +```latex +\letbibmacro*{alias}{name} +``` + +This command defines the macro `alias` to be an alias of the macro +`name`. The definition is perfomed by `\csletcs`. An error is issued if +`name` is undefined. The regular variant of this command sanitizes +`name` while the starred variant does not. +]] + }, + listcount = { + details = [[ +```latex +\listcount +``` + +This counter holds the number of the list item currently being +processed. It is intended for use in list formatting directives and does +not hold a meaningful value when used anywhere else. +]] + }, + liststop = { + details = [[ +```latex +\liststop +``` + +This counter holds the `stop` argument passed to `\printnames` or +`\printlist`. It is intended for use in list formatting directives and +does not hold a meaningful value when used anywhere else. +]] + }, + literal = { + arguments = {{meta = "string"}}, + details = [[ +```latex +\literal{string} +``` + +A literal string to insert into the name sorting key. +]] + }, + lownamepenalty = { + details = [[ +```latex +\lownamepenalty +``` + +Similar to `highnamepenalty`. Please refer to ?? for explanation. The +counter is initialized to half the `\hyphenpenalty` at load-time. Use a +higher value if you dislike the respective linebreaks. If you do not +mind them at all, set this counter to zero. + +```latex +\lownamepenalty +``` + +The penalty used by `\addlowpenspace` and `\addlpthinspace`, see ?? for +details. The counter is initialized to half the `\hyphenpenalty` at +load-time. +]] + }, + mainlang = { + deprecated = true, + details = [[ +```latex +\mainlang +``` + +Switches from the current language to the main document language. This +command is deprecated. Use the text-macro `\textmainlang` instead. With +`babel` this command will need to be wrapped into *two* groups to have +purely local effect. +]] + }, + mancite = { + details = [[ +```latex +\mancite +``` + +Use this command to mark manually inserted citations if you mix +automatically generated and manual citations. This is particularly +useful if the citation style replaces repeated citations by an +abbreviation like *ibidem* which may get ambiguous or misleading +otherwise. Always use `\mancite` in the same context as the manual +citation, e.g. if the citation is given in a footnote, include +`\mancite` in the footnote. The `\mancite` command executes a style +specific reset hook defined with the `\OnManualCitation` command from +??. It also resets the internal <ibidem> and <idem> trackers of +this package. The reset will affect the `\ifciteibid` and `\ifciteidem` +tests discussed in ??. +]] + }, + map = { + arguments = { + {delimiters = {"[", "]"}, meta = "options", optional = true}, + {meta = "restrictions,steps"} + }, + details = [[ +```latex +\map[options]{restrictions,steps} +``` + +A container for an ordered set of map `\step`s, optionally restricted to +particular entrytypes or data sources. This is a grouping element to +allow a set of mapping steps to apply only to specific entrytypes or +data sources. Mapping steps must always be contained within a `\map` +element. The `options` are: + +`overwrite` +As the same option on the parent `\maps` element. This option allows an +override on a per-map group basis. If this option is not specified, the +default is the parent `\maps` element option value. The short form +`overwrite` is equivalent to `overwrite=true`. + +`foreach=<loopval>` +Loop over all `\step`s in this `\map`, setting the special variable +`$MAPLOOP` to each of the comma-separated values contained in `loopval`. +`loopval` can either be the name of a datafield set defined with +`\DeclareDatafieldSet` (see ??), a datasource field which is fetched and +parsed as a comma-separated values list or an explicit comma-separated +values list. `loopval` is determined in this order. This allows the user +to repeat a group of `\step`s for each value `loopval`. Using regexp +maps, it is possible to create a CSV field for use with this +functionality. The special variable `$MAPUNIQ` may also be used in the +`\step`s to generate a random unique string. This can be useful when +creating keys for new entries. An example: + + [style=latex] + \DeclareSourcemap{ + \maps[datatype=bibtex]{ + \map[overwrite, foreach={author,editor, translator}]{ + \step[fieldsource=\regexp{$MAPLOOP}, match={Smith}, replace={Jones}] + } + } + } + +`refsection` +Only apply the contained `\step` commands to entries in the reference +section with number `refsection`. +]] + }, + maxextradate = { + details = [[ +```latex +\maxextradate +``` + +This counter holds the highest number found in any `extradate` field. +]] + }, + maxextratitle = { + details = [[ +```latex +\maxextratitle +``` + +This counter holds the highest number found in any `extratitle` field. +]] + }, + maxitems = { + details = [[ +```latex +\maxitems +``` + +This counter holds the setting of the `maxitems` package option. +]] + }, + maxnames = { + details = [[ +```latex +\maxnames +``` + +This counter holds the setting of the `maxnames` package option. +]] + }, + midsentence = { + arguments = {{literal = "*", optional = true}}, + details = [[ +```latex +\midsentence* +``` + +The starred variant of `\midsentence` differs from the regular one in +that a preceding abbreviation dot is not hidden from the punctuation +tracker, i.e. any code after `\midsentence*` will see a preceding +abbreviation dot. All other punctuation marks are hidden from the +punctuation tracker and capitalization is suppressed. +]] + }, + mkbibacro = { + arguments = {{meta = "text"}}, + details = [[ +```latex +\mkbibacro{text} +``` + +Generic command which typesets an acronym using the small caps variant +of the current font, if available, and as-is otherwise. The acronym +should be given in uppercase letters. +]] + }, + mkbibbold = { + arguments = {{meta = "text"}}, + details = [[ +```latex +\mkbibbold{text} +``` + +Similar in concept to `\mkbibemph` but prints bold text. This is a +simple wrapper around the standard `\textbf` command which incorporates +`\setpunctfont`. If the `punctfont` package option is disabled, this +command behaves like `\textbf`. +]] + }, + mkbibcompletename = { + arguments = {{meta = "text"}}, + details = [[ +```latex +\mkbibcompletename{text} +``` + +The initial value of all default formatting hooks +`\mkbibcompletename<formatorder>`. +]] + }, + ["mkbibcompletename<formatorder>"] = { + arguments = {{meta = "text"}}, + details = [[ +```latex +\mkbibcompletename<formatorder>{text} +``` + +Formatting hook for the complete name in format order <formatorder>. +The default styles use the name format orders <family>, +<family-given> and <given-family>, therefore the following macros +are automatically defined: + + \mkbibcompletenamefamily + \mkbibcompletenamefamilygiven + \mkbibcompletenamegivenfamily + +These formatting hooks should enclose the complete name in the +bibliography macro `\name:<formatorder>`. Initially all hooks expand to +`\mkbibcompletename`. +]] + }, + mkbibcompletenamefamilygiven = { + arguments = {{meta = "text"}}, + details = [[ +```latex +\mkbibcompletenamefamilygiven{text} +``` + +This command, which takes one argument, is used to format the complete +name in `family-given` format order. +]] + }, + mkbibdatelong = { + details = [[ +```latex +\mkbibdatelong +``` + +Takes the names of three field as arguments which correspond to three +date components (in the order year/month/day) and uses their values to +print the date in the language specific long date format. +]] + }, + mkbibemph = { + arguments = {{meta = "text"}}, + details = [[ +```latex +\mkbibemph{text} +``` + +A generic command which prints its argument as emphasized text. This is +a simple wrapper around the standard `\emph` command. Apart from that, +it uses `\setpunctfont` from ?? to adapt the font of the next +punctuation mark following the text set in italics. If the `punctfont` +package option is disabled, this command behaves like `\emph`. +]] + }, + mkbibendnote = { + arguments = {{meta = "text"}}, + details = [[ +```latex +\mkbibendnote{text} +``` + +Similar in concept to `\mkbibfootnote` except that it prints its +argument as an endnote. `\mkbibendnote` removes spurious whitespace +preceding the endnote mark and prevents nested notes. It supports the +`\endnote` command provided by the `endnotes` package as well as the +`\pagenote` command provided by the `pagenote` package and the `memoir` +class. If both commands are available, `\endnote` takes precedence. If +no endnote support is available, `\mkbibendnote` issues an error and +falls back to `\footnote`. By default, `\mkbibendnote` requests +capitalization at the beginning of the note and automatically adds a +period at the end. You may change this behavior by redefining the +`\bibendnotewrapper` macro introduced below. +]] + }, + mkbibfootnote = { + arguments = {{meta = "text"}}, + details = [[ +```latex +\mkbibfootnote{text} +``` + +A generic command which prints its argument as a footnote. This is a +wrapper around the standard LaTeX `\footnote` command which removes +spurious whitespace preceding the footnote mark and prevents nested +footnotes. By default, `\mkbibfootnote` requests capitalization at the +beginning of the note and automatically adds a period at the end. You +may change this behavior by redefining the `\bibfootnotewrapper` macro +introduced below. +]] + }, + mkbibmascord = { + arguments = {{meta = "integer"}}, + details = [[ +```latex +\mkbibmascord{integer} +``` + +Similar to `\mkbibordinal`, but prints a masculine ordinal, if +applicable in the respective language. +]] + }, + ["mkbibname<namepart>"] = { + arguments = {{meta = "text"}}, + details = [[ +```latex +\mkbibname<namepart>{text} +``` + +This command, which takes one argument, is used to format the name part +<namepart> of name list fields. The default datamodel defines the +name parts <family>, <given>, <prefix> and <suffix> and +therefore the following macros are automatically defined: + + \mkbibnamefamily + \mkbibnamegiven + \mkbibnameprefix + \mkbibnamesuffix + +For backwards compatibility with the legacy BibTeX name parts, the +following are also defined, will generate warnings and will set the +correct macro: + + \mkbibnamelast + \mkbibnamefirst + \mkbibnameaffix +]] + }, + mkbibneutord = { + arguments = {{meta = "integer"}}, + details = [[ +```latex +\mkbibneutord{integer} +``` + +Similar to `\mkbibordinal`, but prints a neuter ordinal, if applicable +in the respective language. +]] + }, + mkbibordseries = { + arguments = {{meta = "integer"}}, + details = [[ +```latex +\mkbibordseries{integer} +``` + +Similar to `\mkbibordinal`, but intended for use with the term +<series>. +]] + }, + mkbibparens = { + arguments = {{meta = "text"}}, + details = [[ +```latex +\mkbibparens{text} +``` + +A generic command which wraps its argument in parentheses. This command +is nestable. When nested, it will alternate between parentheses and +brackets, depending on the nesting level. +]] + }, + mkbibsuperscript = { + arguments = {{meta = "text"}}, + details = [[ +```latex +\mkbibsuperscript{text} +``` + +A generic command which prints its argument as superscripted text. This +is a simple wrapper around the standard LaTeX `\textsuperscript` command +which removes spurious whitespace and allows hyphenation of the +preceding word. +]] + }, + mkbibtimezone = { + details = [[ +```latex +\mkbibtimezone +``` + +Modifies a timezone string passed in as the only argument. By default +this changes <Z> to the value of `\bibtimezone`. +]] + }, + mkbibyeardivision = { + arguments = {{meta = "string"}}, + deprecated = true, + details = [[ +```latex +\mkbibyeardivision{string} +``` + +This command takes a year division localisation string and prints the +version of the string corresponding to the setting of the `dateabbrev` +package option. Even though the output of this command is language +specific, its definition is not, hence it is normally not redefined in +localisation modules. +]] + }, + mkcomprange = { + arguments = { + {literal = "*", optional = true}, + {delimiters = {"[", "]"}, meta = "postpro", optional = true}, + {delimiters = {"[", "]"}, meta = "itempostpro", optional = true}, + {meta = "text"} + }, + details = [[ +```latex +\mkcomprange*[postpro][itempostpro]{text} +``` + +This command, which is intended for use in field formatting directives, +will parse its `text` argument for page ranges and compress them. For +example, «125--129» may be formatted as «125--9». You may configure the +behavior of `\mkcomprange` by adjusting the LaTeX counters +`mincomprange`, `maxcomprange`, and `mincompwidth`, as illustrated in +??. The default settings are `10`, `100000`, and `1`, respectively. This +means that the command tries to compress as much as possible by default. +Use `\setcounter` to adjust the parameters. The scanner recognises +`\bibrangedash` and hyphens as range dashes. It will normalize the dash +by replacing any number of consecutive hyphens with `\bibrangedash`. +Lists of ranges delimited with `\bibrangessep` are also supported. The +scanner will normalise any comma or semicolons surrounded by optional +space by replacing them with `\bibrangessep`. If you want to hide a +character from the list/range scanner for some reason, wrap the +character or the entire string in curly braces. The optional `postpro` +argument specifies a macro to be used for post-processing the `text`. +This is important if you want to combine `\mkcomprange` with other +formatting macros which also need to parse their `text` argument, such +as `\mkpageprefix`. Simply nesting these commands will not work as +expected. Use the `postpro` argument to set up the processing chain as +follows: + + \DeclareFieldFormat{postnote}{\mkcomprange[<<{>>\mkpageprefix[pagination]<<}>>]{#1}} + +Note that `\mkcomprange` is executed first, using `\mkpageprefix` as +post-processor. Also note that the `postpro` argument is wrapped in an +additional pair of braces. This is only required in this particular case +to prevent LaTeX 's optional argument scanner from getting confused by +the nested brackets. The starred version of this command differs from +the regular one in the way the `postpro` argument is applied to a list +of values. For example: + + \mkcomprange[\mkpageprefix]{5, 123-129, 423-439} + \mkcomprange*[\mkpageprefix]{5, 123-129, 423-439} + +will output: + + pp. 5, 123-9, 423-39 + p. 5, pp. 123-9, pp. 423-39 + +The second optional argument `itempostpro` is used to post-process each +individual number item in the formatted list. It can be used to convert +numbers from cardinals to ordinals. If only one optional argument is +present, it is treated as `postpro`. +]] + }, + mkdayzeros = { + arguments = {{meta = "integer"}}, + details = [[ +```latex +\mkdayzeros{integer} +``` + +This command strips leading zeros from a day or enforces them, depending +on the `datezeros` package option (??). It is intended for use in the +definition of date formatting macros. If zeros are enforced, this +command calls `\forcezerosmdt` and thus expands its argument with +`\protected@edef`. +]] + }, + mkfirstpage = { + arguments = { + {literal = "*", optional = true}, + {delimiters = {"[", "]"}, meta = "postpro", optional = true}, + {delimiters = {"[", "]"}, meta = "itempostpro", optional = true}, + {meta = "text"} + }, + details = [[ +```latex +\mkfirstpage*[postpro][itempostpro]{text} +``` + +This command, which is intended for use in field formatting directives, +will parse its `text` argument for page ranges and print the start page +of the range only. The scanner recognizes `\bibrangedash` and hyphens as +range dashes. Lists of ranges delimited with `\bibrangessep` are also +supported. If you want to hide a character from the list/range scanner +for some reason, wrap the character or the entire string in curly +braces. The optional `postpro` argument specifies a macro to be used for +post-processing the `text`. See `\mkcomprange` on how to use this +argument. The starred version of this command differs from the regular +one in the way the `postpro` argument is applied to a list of values. +The second optional argument `itempostpro` is used to post-process each +individual number item in the formatted list. It can be used to convert +numbers from cardinals to ordinals. If only one optional argument is +present, it is treated as `postpro`. For example: + + \mkfirstpage[\mkpageprefix]{5, 123-129, 423-439} + \mkfirstpage*[\mkpageprefix]{5, 123-129, 423-439} + +will output: + + pp. 5, 123, 423 + p. 5, p. 123, p. 423 +]] + }, + mknormrange = { + arguments = { + {literal = "*", optional = true}, + {delimiters = {"[", "]"}, meta = "postpro", optional = true}, + {delimiters = {"[", "]"}, meta = "itempostpro", optional = true}, + {meta = "text"} + }, + details = [[ +```latex +\mknormrange*[postpro][itempostpro]{text} +``` + +This command, which is intended for use in field formatting directives, +will parse its `text` argument for page ranges and will normalise them. +The command is similar to `\mkcomprange` except that the page ranges +will not be compressed. The scanner recognises `\bibrangedash` and +hyphens as range dashes. It will normalize the dash by replacing any +number of consecutive hyphens with `\bibrangedash`. Lists of ranges +delimited with `\bibrangessep` are also supported. The scanner will +normalise any comma or semicolons surrounded by optional space by +replacing them with `\bibrangessep`. If you want to hide a character +from the list/range scanner for some reason, wrap the character or the +entire string in curly braces. The optional `postpro` argument specifies +a macro to be used for post-processing the `text`. See `\mkcomprange` on +how to use this argument. The starred version of this command differs +from the regular one in the way the `postpro` argument is applied to a +list of values. The second optional argument `itempostpro` is used to +post-process each individual number item in the formatted list. It can +be used to convert numbers from cardinals to ordinals. If only one +optional argument is present, it is treated as `postpro`. +]] + }, + mkpagetotal = { + arguments = { + {delimiters = {"[", "]"}, meta = "pagination", optional = true}, + {delimiters = {"[", "]"}, meta = "postpro", optional = true}, + {meta = "text"} + }, + details = [[ +```latex +\mkpagetotal[pagination][postpro]{text} +``` + +This command is similar to `\mkpageprefix` except that it is intended +for the `pagetotal` field of bibliography entries, i.e. it will print +«123 pages» rather than «page 123». The optional `pagination` argument +defaults to `bookpagination`. The spacing inserted between the +pagination suffix and the `text` may be modified by redefining the macro +`\ppspace`. The optional `postpro` argument specifies a macro to be used +for post-processing the `text`. If only one optional argument is given, +it is taken as `pagination`. Here is a typical example: + + \DeclareFieldFormat{pagetotal}{<<\mkpagetotal[bookpagination]{#1}>>} + +The optional argument `bookpagination` is omissible in this case. The +pagination strings are taken from `<pagination>total` and +`<pagination>totals`. + +@>X@p0.25@p0.25@p0.25@ & +(r)1-1 & & & +(r)2-2(r)3-3 11--15 & 11--5 & 11--15 & 11--15 +111--115 & 111--5 & 111--5 & 111--115 +1111--1115 & 1111--5 & 1111--5 & 1111--5 +& & & +(r)2-2(r)3-3 1111--1115 & 1111--5 & 1111--5 & 1111--5 +1111--1155 & 1111--55 & 1111--55 & 1111--1155 +1111--1555 & 1111--555 & 1111--1555 & 1111--1555 +& & & +(r)2-2(r)3-3 1111--1115 & 1111--5 & 1111--15 & 1111--115 +1111--1155 & 1111--55 & 1111--55 & 1111--155 +1111--1555 & 1111--555 & 1111--555 & 1111--555 +]] + }, + mkvolcitenote = { + arguments = {{meta = "volume"}, {meta = "pages"}}, + details = [[ +```latex +\mkvolcitenote{volume}{pages} +``` + +This macro formats the `volume` and `pages` arguments of `\volcite` and +related commands (??) when they are passed on to the underlying citation +command. +]] + }, + mkyearzeros = { + arguments = {{meta = "integer"}}, + details = [[ +```latex +\mkyearzeros{integer} +``` + +This command strips leading zeros from a year or enforces them, +depending on the `datezeros` package option (??). It is intended for use +in the definition of date formatting macros. If zeros are enforced, this +command calls `\forcezerosy` and thus expands its argument with +`\protected@edef`. +]] + }, + multicitecount = { + details = [[ +```latex +\multicitecount +``` + +This counter is similar to `citecount` but only available in multicite +commands. It holds the number of the citation currently being processed. +Note that this citation may consist of more than one entry key. This +information is provided by the `citetotal` and `citecount` counters. +]] + }, + multicitedelim = { + details = [[ +```latex +\multicitedelim +``` + +The delimiter printed between citations if multiple entry keys are +passed to a single citation command. The default is a semicolon plus an +interword space. + +```latex +\multicitedelim +``` + +The delimiter printed between citations if multiple entry keys are +passed to a single citation command. This command should be incorporated +in the definition of all citation commands, for example in the `sepcode` +argument passed to `\DeclareCiteCommand`. See ?? for details. The +default is a semicolon plus an interword space. +]] + }, + multicitesubentrydelim = { + details = [[ +```latex +\multicitesubentrydelim +``` + +The delimiter printed between subentry citations of the same set. This +delimiter is only used in citation styles that reduce citations of the +same set to a more compact form (`subentry` of `numeric-comp`). The +default is a comma. +]] + }, + multipostnotedelim = { + details = [[ +```latex +\multipostnotedelim +``` + +The delimiter to be printed before the `multipostnote` argument of a +citation command. +]] + }, + multiprenotedelim = { + details = [[ +```latex +\multiprenotedelim +``` + +The delimiter printed after the `multiprenote` argument of a citation +command. See ?? for details. The default is `\prenotedelim`. +]] + }, + namelabeldelim = { + details = [[ +```latex +\namelabeldelim +``` + +The delimiter printed between the name/title and the label by alphabetic +and numeric citation styles. The default definition is an interword +space. + +```latex +\namelabeldelim +``` + +The delimiter printed between the name/title and the label. This command +should be incorporated in the definition of all citation commands of +alphabetic and numeric citation styles. The default definition is an +interword space. +]] + }, + nametitledelim = { + details = [[ +```latex +\nametitledelim +``` + +The delimiter printed between the author/editor and the title by +author-title and some verbose citation styles and in the bibliography. +In author-year bibliography styles this delimiter is placed after the +author/editor and year and before the title. The default definition +inside bibliographies is the now deprecated `\labelnamepunct` and is a +comma plus an interword space otherwise. + +```latex +\nametitledelim +``` + +The delimiter to be printed between the author/editor and the title. +This command should be incorporated in the definition of all citation +commands of author-title and some verbose citation styles and in the +bibliography drivers---in author-year bibliographies `\nametitledelim` +may be printed between the author/editor-year block and the title. The +default definition inside bibliographies is the now deprecated +`\labelnamepunct` (for backwrds compatibility reasons) and is a comma +plus an interword space otherwise. +]] + }, + nbhyphen = { + details = [[ +```latex +\nbhyphen +``` + +An explicit, non-breakable hyphen intended for compound words. In +contrast to a literal <`-`>, this command does not permit line +breaks at the hyphen but still allows hyphenation in the rest of the +word. It is similar to the `"~` shorthand provided by some language +modules of the `babel`/`polyglossia` packages. +]] + }, + newbibmacro = { + arguments = { + {literal = "*", optional = true}, + {meta = "name"}, + {delimiters = {"[", "]"}, meta = "arguments", optional = true}, + {delimiters = {"[", "]"}, meta = "optional", optional = true}, + {meta = "definition"} + }, + details = [[ +```latex +\newbibmacro{name}[arguments][optional]{definition} +\newbibmacro*{name}[arguments][optional]{definition} +``` + +Defines a macro to be executed via `\usebibmacro` later. The syntax of +this command is very similar to `\newcommand` except that `name` may +contain characters such as numbers and punctuation marks and does not +start with a backslash. The optional argument `arguments` is an integer +specifying the number of arguments taken by the macro. If `optional` is +given, it specifies a default value for the first argument of the macro, +which automatically becomes an optional argument. In contrast to +`\newcommand`, `\newbibmacro` issues a warning message if the macro is +already defined, and automatically falls back to `\renewbibmacro`. As +with `\newcommand`, the regular variant of this command uses the `\long` +prefix in the definition while the starred one does not. If a macro has +been declared to be long, it may take arguments containing `\par` +tokens. `\newbibmacro` and `\renewbibmacro` are provided for +convenience. Style authors are free to use `\newcommand` or `\def` +instead. However, note that most shared definitions found in +`biblatex.def` are defined with `\newbibmacro`, hence they must be used +and modified accordingly. +]] + }, + newblock = { + details = [[ +```latex +\newblock +``` + +Records the end of a block. This command does not print anything, it +merely marks the end of the block. The block delimiter `\newblockpunct` +will be inserted by a subsequent `\printtext`, `\printfield`, +`\printlist`, `\printnames`, or `\bibstring` command. You may use +`\newblock` at suitable places without having to worry about spurious +blocks. A new block will only be started by the next `\printfield` (or +similar) command if this command prints anything. See ?? for further +details. +]] + }, + newrefcontext = { + arguments = { + { + delimiters = {"[", "]"}, + meta = "key=value, ... ", + optional = true + }, + {meta = "name"} + }, + details = [[ +```latex +\newrefcontext[key=value, ... ]{name} +``` + +This command is similar to the `refcontext` environment except that it +is a stand-alone command rather than an environment. It automatically +ends any previous reference context section begun with `\newrefcontext` +(if any) and immediately starts a new one. Note that the context section +started by the last `\newrefcontext` command in the document will extend +to the very end of the document. Use `\endrefcontext` if you want to +terminate it earlier. +]] + }, + newunitpunct = { + details = [[ +```latex +\newunitpunct +``` + +The separator inserted between <units> in the sense explained in ??. +This will usually be a period or a comma plus an interword space. The +default definition is a period and a space. +]] + }, + nocite = { + action = "cite", + arguments = {{meta = "key"}}, + details = [[ +```latex +\nocite{key} +\nocite{*} +``` + +This command is similar to the standard LaTeX `\nocite` command. It adds +the `key` to the bibliography without printing a citation. If the `key` +is an asterisk, all entries available in the in-scope bibliography +datasource(s) are added to the bibliography. Like all other citation +commands, `\nocite` commands in the document body are local to the +enclosing `refsection` environment, if any. In contrast to standard +LaTeX , `\nocite` may also be used in the document preamble. In this +case, the references are assigned to reference section 0. For the +purposes of ordering citations by appearance `\nocite` will behave like +all other cite commands, with the added rule that a `\nocite` issued in +the preamble is treated as coming before all explicit citations in +reference section 0 from the document body. +]] + }, + noinherit = { + arguments = {{meta = "source"}}, + details = [[ +```latex +\noinherit{source} +``` + +Unconditionally prevents inheritance of the `source` field. +]] + }, + nopunct = { + details = [[ +```latex +\nopunct +``` + +Adds an internal marker which will cause the next punctuation command to +print nothing. +]] + }, + parencite = { + action = "cite", + arguments = { + {literal = "*", optional = true}, + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = [[ +```latex +\parencite*[prenote][postnote]{key} +``` + +This command is provided by all author-year and author-title styles. It +is similar to the regular `\parencite` command but merely prints the +year or the title, respectively. +]] + }, + parenlevel = { + details = [[ +```latex +\parenlevel +``` + +The current nesting level of parentheses and/or brackets. This +information is only available if the `parentracker` from ?? is enabled. +]] + }, + parentext = { + arguments = {{meta = "text"}}, + details = [[ +```latex +\parentext{text} +``` + +This command wraps the `text` in context sensitive parentheses. +]] + }, + pertype = { + arguments = {{meta = "entrytype"}}, + details = [[ +```latex +\pertype{entrytype} +``` + +Restricts all `\step`s in this `\map` element to entries of the named +`entrytype`. Multiple `\pertype` restrictions are allowed within a +`\map` element. +]] + }, + pnfmt = { + arguments = {{meta = "text"}}, + details = [[ +```latex +\pnfmt{text} +``` + +This command formats its argument `text` in the same format as +`postnote`. The command can be used to format a page range while adding +additional text in the postnote argument of a cite command. + + \autocite[\pnfmt{378-381, 383} and more]{sigfridsson} +]] + }, + postnotedelim = { + details = [[ +```latex +\postnotedelim +``` + +The delimiter printed before the `postnote` argument of a citation +command. See ?? for details. The default is a comma plus an interword +space. +]] + }, + ppno = { + details = [[ +```latex +\ppno +``` + +Similar to `\pno` but forces a range prefix. See ?? for further details +and usage instructions. Note that this command is only available locally +in citations and the bibliography. +]] + }, + prenotedelim = { + details = [[ +```latex +\prenotedelim +``` + +The delimiter to be printed after the `prenote` argument of a citation +command. The default is an interword space. +]] + }, + printbibliography = { + arguments = { + { + delimiters = {"[", "]"}, + meta = "key=value, ... ", + optional = true + } + }, + details = [[ +```latex +\printbibliography[key=value, ... ] +``` + +This command prints the bibliography. It takes one optional argument, +which is a list of options given in `key=value`notation. The following +options are available: +]] + }, + printbiblist = { + arguments = { + { + delimiters = {"[", "]"}, + meta = "key=value, ... ", + optional = true + }, + {meta = "biblistname"} + }, + details = [[ +```latex +\printbiblist[key=value, ... ]{biblistname} +``` + +This command prints a bibliography list. It takes an optional argument, +which is a list of options given in `key=value`notation. Valid options +are all options supported by `\printbibliography` (??) except +`resetnumbers` and `omitnumbers`. Additionaly, the two options `driver` +and `biblistfilter` are available. If there are any `refsection` +environments in the document, the bibliography list will be local to +these environments; see ?? for details. By default, this command uses +the heading `biblist`. See ?? for details. + +The `biblistname` is a mandatory argument which names the bibliography +list. This name is used to identify: + +- The default bibliography driver used to print the list entries + +- A default bibliography list filter declared with + `\DeclareBiblistFilter` (see ??) used to filter the entries returned + from `biber` + +- A default check declared with `\defbibcheck` (see ??) used to + post-process the list entries + +- The default bib environment to use + +- The default sorting template to use + +The two additional options can be used to change some of the defaults +set by the mandatory argument. + +`driver=<driver>` +Change the bibliography driver used to print the list entries. + +`biblistfilter=<biblistfilter>` +Change the bibliography list filter used to filter the entries. +`biblistfilter` must be a valid bibliography list filter defined with +`\DeclareBiblistFilter` (see ??). + +In terms of sorting the list, the default is to sort using the sorting +template named after the bibliography list (if it exists) and only then +to fall back to the current context sorting template if this is not +defined (see ??). + +The most common bibliography list is a list of shorthand abbreviations +for certain entries and so this has a convenience alias +`\printshorthands[…]` for backwards compatibility which is defined as: + + \printbiblist[...]{shorthand} + +`biblatex`provides automatic support for data source fields in the +default data model marked as <Label fields> (See ??). Such fields +automatically have defined for them: + +- A default bib environment (See ??) + +- A bibliography list filter (See ??) + +- Some supporting formats and lengths (See ?? and ??) + +Therefore only a minimal setup is required to print bibliography lists +with such fields. For example, to print a list of journal title +abbreviations, you can minimally put this in your preamble: + + \DeclareBibliographyDriver{shortjournal}{% + \printfield{journaltitle}} + +Then you can put this in your document where you want to print the list: + + \printbiblist[title={Journal Shorthands}]{shortjournal} + +Since `shortjournal` is defined in the default data model as a <Label +field>, this example: + +- Uses the automatically created <shortjournal> bib environment + +- Uses the automatically created <shortjournal> bibliography list + filter to return only entries with a `shortjournal` field in the + `.bbl` + +- Uses the defined <shortjournal> bibliography driver to print the + entries + +- Uses the default <biblist> heading but overrides the title with + <Journal Shorthands> + +- Uses the current bibliography context sorting template if no + template exists with the name `shortjournal` + +Often, you will want to sort on the label field of the list and since a +sorting template is automatically picked up if it is named after the +list, in this case you could simply do: + + \DeclareSortingTemplate{shortjournal}{ + \sort{ + \field{shortjournal} + } + } + +Naturally all defaults can be overridden by options to `\printbiblist` +and definitions of the environments, filters etc. and in this way +arbitrary types of bibliography lists can be printed containing a +variety of information from the bibliography data. +]] + }, + printdate = { + details = [[ +```latex +\printdate +``` + +This command prints the date of the entry, as specified in the fields +`date` or `month`/`year`. The date format is controlled by the package +option `date` from ??. Additional formatting (fonts etc.) may be applied +by adjusting the field format `date` (??). Note that this command +interfaces with the punctuation tracker. There is no need to wrap it in +a `\printtext` command. +]] + }, + printlabeldate = { + details = [[ +```latex +\printlabeldate +``` + +Similar to `\printdate` but prints the date field determined by +`\DeclareLabeldate`. The date format is controlled by the package option +`labeldate` from ??. Additional formatting may be applied by adjusting +the field format `labeldate` (??). +]] + }, + printlist = { + arguments = { + {delimiters = {"[", "]"}, meta = "format", optional = true}, + {delimiters = {"[", "]"}, meta = "start--stop", optional = true}, + {meta = "literal list"} + }, + details = [[ +```latex +\printlist[format][start--stop]{literal list} +``` + +This command loops over all items in a `literal list`, starting at item +number `start` and stopping at item number `stop`, including `start` and +`stop` (all lists are numbered starting at 1). Each item is printed +using the formatting directive `format`, as defined with +`\DeclareListFormat`. If a type-specific `format` has been declared, the +type-specific formatting directive takes precedence over the generic +one. If the `literal list` is undefined, nothing is printed. If the +`format` is omitted, `\printlist` tries using the name of the list as a +format name. In this case, any type-specific formatting directive will +also take precedence over the generic one. If all of these formats are +undefined, it falls back to `default` as a last resort. The `start` +argument defaults to 1; `stop` defaults to the total number of items in +the list. If the total number is greater than `maxitems`, `stop` +defaults to `minitems` (see ??). See `\printnames` for further details. +Note that `\printlist` provides the name of the literal list currently +being processed in `\currentlist` for use in list formatting directives. +]] + }, + printtext = { + arguments = { + {delimiters = {"[", "]"}, meta = "format", optional = true}, + {meta = "text"} + }, + details = [[ +```latex +\printtext[format]{text} +``` + +This command prints `text`, which may be printable text or arbitrary +code generating printable text. It clears the punctuation buffer before +inserting `text` and informs `biblatex`that printable text has been +inserted. This ensures that all preceding and following `\newblock` and +`\newunit` commands have the desired effect. `\printfield` and +`\printnames` as well as `\bibstring` and its companion commands (see +??) do that automatically. Using this command is required if a +bibliography styles inserts literal text (including the commands from +??) to ensure that block and unit punctuation works as advertised in ??. +The optional `format` argument specifies a field formatting directive to +be used to format `text`. This may also be useful when several fields +are to be printed as one chunk, for example, by enclosing the entire +chunk in parentheses or quotation marks. If a type-specific `format` has +been declared, the type-specific formatting directive takes precedence +over the generic one. If the `format` is omitted, the `text` is printed +as is. See also ?? for some practical hints. +]] + }, + printunit = { + arguments = {{literal = "*", optional = true}, {meta = "punctuation"}}, + details = [[ +```latex +\printunit*{punctuation} +``` + +The `\printunit` command is similar to `\setunit` except that +`punctuation` persists in the buffer. This ensures that `punctuation` is +inserted before the next non-empty field printed by the `\printtext`, +`\printfield`, `\printlist`, `\printnames`, or `\bibstring` +commands---regardless of any intermediate calls to `\newunit` or +`\setunit`. +]] + }, + providebibmacro = { + arguments = { + {literal = "*", optional = true}, + {meta = "name"}, + {delimiters = {"[", "]"}, meta = "arguments", optional = true}, + {delimiters = {"[", "]"}, meta = "optional", optional = true}, + {meta = "definition"} + }, + details = [[ +```latex +\providebibmacro*{name}[arguments][optional]{definition} +``` + +Similar to `\newbibmacro` but only defines `name` if it is undefined. +This command is similar in concept to `\providecommand`. +]] + }, + psq = { + details = [[ +```latex +\psq +``` + +In the `postnote` argument to a citation command, this command indicates +a range of two pages where only the starting page is given. See ?? for +further details and usage instructions. The suffix printed is the +localisation string `sequens`, see ??. The spacing inserted between the +suffix and the page number may be modified by redefining the macro +`\sqspace`. The default is an unbreakable interword space. Note that +this command is only available locally in citations and the +bibliography. +]] + }, + refsection = { + details = [[ +```latex +\refsection +``` + +This counter indicates the current `refsection` environment. When +queried in a bibliography heading, the counter returns the value of the +`refsection` option passed to `\printbibliography`. +]] + }, + regexp = { + arguments = {{meta = "PCRE"}}, + details = [[ +```latex +\regexp{PCRE} +``` + +This command can be used with any command accepting a regular expression +key to protect a regular expression from being interpreted by TeX so +that it is passed through to `biber`correctly. Regular expressions often +contain sequences of characters that are also valid TeX commands but +which should not be interpreted as such. The argument is a normal PCRE +(Perl Compatible Regular Expression<https://perldoc.perl.org/perlre>). +Perl escape sequences like `\t` for a tab, `\n` for a newline, `\A` for +the start of a string or `\d` for a digit can be used, without +TeX trying to execute them as commands, as can be special characters +like `^`, `_` or `{..}` and `#`. Only the % must be protected: to match +a single % in the bib, use \\% in the regular expression, a \\% is +matched by \\\\%. +]] + }, + relateddelim = { + details = [[ +```latex +\relateddelim +``` + +The generic separator between the data of multiple related entries. The +default definition is an optional dot plus linebreak. Here is an example +where volumes A-E are related entries of the 5 volume main work: + + Donald E. Knuth. Computers & Typesetting. 5 vols. Reading, Mass.: Addison-Wesley, 1984-1986. + Vol. A: The TEXbook. 1984. + Vol. B: TEX: The Program. 1986. + Vol. C: The METAFONTbook. By. 1986. + Vol. D: METAFONT: The Program. 1986. + Vol. E: Computer Modern Typefaces. 1986. +]] + }, + relatedpunct = { + details = [[ +```latex +\relatedpunct +``` + +The separator between the `relatedtype` bibliography localisation string +and the data from the first related entry. +]] + }, + renewbibmacro = { + arguments = { + {literal = "*", optional = true}, + {meta = "name"}, + {delimiters = {"[", "]"}, meta = "arguments", optional = true}, + {delimiters = {"[", "]"}, meta = "optional", optional = true}, + {meta = "definition"} + }, + details = [[ +```latex +\renewbibmacro*{name}[arguments][optional]{definition} +``` + +Similar to `\newbibmacro` but redefines `name`. In contrast to +`\renewcommand`, `\renewbibmacro` issues a warning message if the macro +is undefined, and automatically falls back to `\newbibmacro`. +]] + }, + resetpunctfont = { + details = [[ +```latex +\resetpunctfont +``` + +This command resets the unit punctuation font defined with +`\setpunctfont` before it takes effect. If the `punctfont` package +option is disabled, this command does nothing. +]] + }, + restorebibmacro = { + arguments = {{meta = "name"}}, + details = [[ +```latex +\restorebibmacro{name} +``` + +These commands save and restore the macro `name`, where `name` is the +identifier of a macro defined with `\newbibmacro`. Both commands work +within a local scope. They are mainly provided for use in localisation +files. +]] + }, + restorecommand = { + arguments = {{meta = "command"}}, + details = [[ +```latex +\restorecommand{command} +``` + +These commands save and restore any `command`, which must be a command +name starting with a backslash. Both commands work within a local scope. +They are mainly provided for use in localisation files. +]] + }, + restorefieldformat = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "format"} + }, + details = [[ +```latex +\restorefieldformat[entry type]{format} +``` + +These commands save and restore the formatting directive `format`, as +defined with `\DeclareFieldFormat`. Both commands work within a local +scope. They are mainly provided for use in localisation files. +]] + }, + restorelist = { + arguments = {{meta = "literal list"}, {meta = "macro"}}, + details = [[ +```latex +\restorelist{literal list}{macro} +``` + +Restores a `literal list` from a `macro` defined with `\savelist` +before. The list is restored within a local scope. +]] + }, + restorelistformat = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "format"} + }, + details = [[ +```latex +\restorelistformat[entry type]{format} +``` + +These commands save and restore the formatting directive `format`, as +defined with `\DeclareListFormat`. Both commands work within a local +scope. They are mainly provided for use in localisation files. +]] + }, + restorelistwrapperformat = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "format"} + }, + details = [[ +```latex +\restorelistwrapperformat[entry type]{format} +``` + +These commands save and restore the formatting directive `format`, as +defined with `\DeclareListWrapperFormat`. Both commands work within a +local scope. They are mainly provided for use in localisation files. +]] + }, + restorenameformat = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "format"} + }, + details = [[ +```latex +\restorenameformat[entry type]{format} +``` + +These commands save and restore the formatting directive `format`, as +defined with `\DeclareNameFormat`. Both commands work within a local +scope. They are mainly provided for use in localisation files. +]] + }, + restorenamewrapperformat = { + arguments = { + {delimiters = {"[", "]"}, meta = "entry type", optional = true}, + {meta = "format"} + }, + details = [[ +```latex +\restorenamewrapperformat[entry type]{format} +``` + +These commands save and restore the formatting directive `format`, as +defined with `\DeclareNameWrapperFormat`. Both commands work within a +local scope. They are mainly provided for use in localisation files. +]] + }, + savefield = { + arguments = { + {literal = "*", optional = true}, + {meta = "field"}, + {meta = "macro"} + }, + details = [[ +```latex +\savefield*{field}{macro} +``` + +Copies an unformatted `field` to a `macro`. The regular variant of this +command defines the `macro` globally, the starred one works locally. +]] + }, + savefieldcs = { + arguments = { + {literal = "*", optional = true}, + {meta = "field"}, + {meta = "csname"} + }, + details = [[ +```latex +\savefieldcs*{field}{csname} +``` + +Similar to `\savefield`, but takes the control sequence name `csname` +(without a leading backslash) as an argument, rather than a macro name. +]] + }, + savelist = { + arguments = { + {literal = "*", optional = true}, + {meta = "literal list"}, + {meta = "macro"} + }, + details = [[ +```latex +\savelist*{literal list}{macro} +``` + +Copies an unformatted `literal list` to a `macro`. The regular variant +of this command defines the `macro` globally, the starred one works +locally. +]] + }, + savelistcs = { + arguments = { + {literal = "*", optional = true}, + {meta = "literal list"}, + {meta = "csname"} + }, + details = [[ +```latex +\savelistcs*{literal list}{csname} +``` + +Similar to `\savelist`, but takes the control sequence name `csname` +(without a leading backslash) as an argument, rather than a macro name. +]] + }, + savename = { + arguments = { + {literal = "*", optional = true}, + {meta = "name list"}, + {meta = "macro"} + }, + details = [[ +```latex +\savename*{name list}{macro} +``` + +Copies an unformatted `name list` to a `macro`. The regular variant of +this command defines the `macro` globally, the starred one works +locally. +]] + }, + savenamecs = { + arguments = { + {literal = "*", optional = true}, + {meta = "name list"}, + {meta = "csname"} + }, + details = [[ +```latex +\savenamecs*{name list}{csname} +``` + +Similar to `\savename`, but takes the control sequence name `csname` +(without a leading backslash) as an argument, rather than a macro name. +]] + }, + setunit = { + arguments = {{literal = "*", optional = true}, {meta = "punctuation"}}, + details = [[ +```latex +\setunit*{punctuation} +``` + +The `\setunit` command is similar to `\newunit` except that it uses +`punctuation` instead of `\newunitpunct`. The starred variant differs +from the regular version in that it checks if the last `\printtext`, +`\printfield`, `\printlist`, `\printnames`, or `\bibstring` command did +actually print anything. If not, it does nothing. +]] + }, + smartand = { + details = [[ +```latex +\smartand +``` + +This counter controls the behavior of the internal <smart and> +command. When set to 1, it prints <y> or <e>, depending on the +context. When set to 2, it always prints <y>. When set to 3, it +always prints <e>. When set to 0, the <smart and> feature is +disabled. This counter is initialized to 1 at load-time and may be +changed in the preamble. Note that setting this counter to a positive +value implies that the Spanish localisation module ignores +`\finalnamedelim` and `\finallistdelim`. +]] + }, + sortalphaothers = { + details = [[ +```latex +\sortalphaothers +``` + +Similar to `\labelalphaothers` but used in the sorting process. Setting +it to a different value is advisable if the latter contains formatting +commands, for example: + + \renewcommand*{\labelalphaothers}{\textbf{+}} + \renewcommand*{\sortalphaothers}{+} + +If `\sortalphaothers` is not redefined, it defaults to +`\labelalphaothers`. + +```latex +\sortalphaothers +``` + +Similar to `\labelalphaothers` but used in the sorting process. Setting +it to a different value is advisable if the latter contains formatting +commands. If `\sortalphaothers` is not redefined, it defaults to +`\labelalphaothers`. +]] + }, + stdpunctuation = { + details = [[ +```latex +\stdpunctuation +``` + +Undoes the settings applied by `\uspunctuation`, restoring standard +punctuation. As standard punctuation is the default setting, you only +need this command to override a previously executed `\uspunctuation` +command. See ?? for details. +]] + }, + step = { + arguments = {{delimiters = {"[", "]"}, meta = "options", optional = true}}, + details = [[ +```latex +\step[options] +``` + +A mapping step. Each step is applied sequentially to every relevant +entry where <relevant> means those entries which correspond to the +data source type, entrytype and data source name restrictions mentioned +above. Each step is applied to the entry as it appears after the +application of all previous steps. The mapping performed by the step is +determined by the following `option`s: + +`typesource=<entrytype>` + +`typetarget=<entrytype>` + +`fieldsource=<entryfield>` + +`notfield=<entryfield>` + +`fieldtarget=<entryfield>` + +`match=<regexp>` + +`matchi=<regexp>` + +`notmatch=<regexp>` + +`notmatchi=<regexp>` + +`matches=<regexp>` + +`matchesi=<regexp>` + +`replace=<regexp>` + +`fieldset=<entryfield>` + +`fieldvalue=<string>` + +`entryclone=<clonekey>` + +`entrynew=<entrynewkey>` + +`entrynewtype=<string>` + +`entrytarget=<string>` + +`cited` + +`nocited` + +`citedornocited` + +`allnocited` + +`starnocited` + +`entrynocite` + +`entrynull` + +`append` + +`appendstrict` + +`final` + +`null` + +`origfield` + +`origfieldval` + +`origentrytype` +For all boolean `\step` options, the short form `option` is equivalent +to `option=true`. The following rules for a mapping step apply: + +Note that the options `cited`, `nocited`, `citedornocited`, `allnocited` +and `starnocited` are unique in that they can make the results of a +sourcemap differ depending on the refsection. This is because a +datasource to which source mapping applies may be used in several +refsections and source mappings are applied when fetching the data from +the datasources for a refsection. Citation commands are local to a +refsection and therefore may differ for the same entry from refsection +to refsection. For example, the same entry may be `\cite`d in one +refsection but `\nocite`d in another, resulting in different source map +results and therefore data between the refsections. This can be avoided +if desired, by limiting source maps to specific refsections only (see +`refsection` option to the `\map` command above). + +- If `entrynew` is set, a new entry is created with the entry key + `entrynewkey` and the entry type given in the option `entrynewtype`. + This entry is only in-scope during the processing of the current + entry and can be referenced by `entrytarget`. In `entrynewkey`, you + may use standard Perl regular expression backreferences to captures + from a previous `match` step. + +- When a `fieldset` step has `entrytarget` set to the entrykey of an + entry created by `entrynew`, the target for the field set will be + the `entrytarget` entry rather than the entry being currently + processed. This allows users to create new entries and set fields in + them. + +- If `entrynocite` is used in a `entrynew` or `entryclone` step, the + new/clone entry will be included in the `.bbl` as if the entry/clone + had been `\nocite`ed in the document. + +- If `entrynull` is set, processing of the `\map` immediately + terminates and the current entry is not created. It is as if it did + not exist in the datasource. Obviously, you should select the + entries which you want to apply this to using prior mapping steps. + +- If `entryclone` is set, a clone of the entry is created with an + entry key `clonekey`. Obviously this may cause labelling problems in + author/year styles etc. and should be used with care. The cloned + entry is in-scope during the processing of the current entry and can + be modified by passing its key as the value to `entrytarget`. In + `clonekey`, you may use standard Perl regular expression + backreferences to captures from a previous `match` step. + +- If `cited` is used then only apply the step if the entry key of an + entry was specifically cited via `\cite`. + +- If `nocited` is used then only apply the step if the entry key of an + entry was specifically nocited via `\nocite` or was included via + `\nocite{*}`. + +- If `citedornocited` is used then only apply the step if the entry + key of an entry was specifically cited via `\cite` or specifically + nocited via `\nocite`. + +- If `allnocited` is used then only apply the step if the entry key of + an entry was included via `\nocite{*}`. + +- If `starnocited` is used then only apply the step if the entry key + of an entry was included solely because of `\nocite{*}`. This + implies that the entry was neither explicitly `\cite`ed nor + explicitly `\nocite`ed. + +- Change the `typesource` `entrytype` to the `typetarget` `entrytype`, + if defined. If `final` is `true` then if the `entrytype` of the + entry is not `typesource`, processing of the parent `\map` + immediately terminates. + +- Change the `fieldsource` `entryfield` to `fieldtarget`, if defined. + If `final` is `true` then if there is no `fieldsource` `entryfield` + in the entry, processing of the parent `\map` immediately + terminates. + +- If `notfield` is true only if the `entryfield` does not exist. + Usually used with `final` so that if an entry does contain + `entryfield`, the map terminates. + +- If `match` is defined but `replace` is not, only apply the step if + the `fieldsource` `entryfield` matches the `match` regular + expression (logic is reversed if you use `notmatch` and + case-insensitive if you use the versions ending in <i>)[1]. You + may use capture parenthesis as usual and refer to these (\$1...\$9) + in later `fieldvalue` specifications. This allows you to pull out + parts of some fields and put these parts in other fields. + +- Perform a regular expression match and replace on the value of the + `fieldsource` `entryfield` if `match` and `replace` are defined. + +- If `matches` is defined, it should be a comma-separated list of + literal strings which are replaced by corresponding locations in a + comma-separated list provided in `replace`. The lists must have the + same number of elements or the step will be skipped. `matchesi` is + the same but case-insensitive. + +- If `fieldset` is defined, then its value is `entryfield` which will + be set to a value specified by further options. If `overwrite` is + false for this step and the field to set already exists then the map + step is ignored. If `final` is also true for this step, then + processing of the parent map stops at this point. If `append` is + true, then the value to set is appended to the current value of + `entryfield`. `appendstrict` only appends to `entryfield` if + `entryfield` is not empty. The value to set is specified by a + mandatory one and only one of the following options: + + - `fieldvalue` --- The `fieldset` `entryfield` is set to the + `fieldvalue` `string` + + - `null` --- The `fieldset` `entryfield` is ignored, as if it did + not exist in the datasource + + - `origentrytype` --- The `fieldset` `entryfield` is set to the + most recently mentioned `typesource` `entrytype` name + + - `origfield` --- The `fieldset` `entryfield` is set to the most + recently mentioned `fieldsource` `entryfield` name + + - `origfieldval` --- The `fieldset` `entryfield` is set to the + most recently mentioned `fieldsource` value + +[1] Regular expressions are full Perl 5.16 regular expressions. This +means you may need to deal with special characters, see examples. +]] + }, + stripzeros = { + arguments = {{meta = "integer"}}, + details = [[ +```latex +\stripzeros{integer} +``` + +This command strips leading zeros from a number. It is intended for date +formatting and ordinals. + +For every field marked as a <Label field> in the data model, a +formatting directive is created as per `shorthandwidth` above. Since +`shorthand` is so marked in the default data model, this functionality +is a superset of that described for `shorthandwidth`. + +Similar to `shorthandwidth`, but referring to the `labelnumber` field +and the length register `\labelnumberwidth`. Numeric styles should +adjust this directive such that it corresponds to the format used in the +bibliography. + +Similar to `shorthandwidth`, but referring to the `labelalpha` field and +the length register `\labelalphawidth`. Alphabetic styles should adjust +this directive such that it corresponds to the format used in the +bibliography. + +A special formatting directive for use with `\printfield` and +`\printtext`. This directive wraps its argument in a `\bibhyperref` +command, see ?? for details. + +A special formatting directive for use with `\printfield` and +`\printtext`. It wraps its argument in a `\bibhyperlink` command, see ?? +for details. The `name` argument passed to `\bibhyperlink` is the value +of the `entrykey` field. + +A special formatting directive for use with `\printfield` and +`\printtext`. It wraps its argument in a `\bibhypertarget` command, see +?? for details. The `name` argument passed to `\bibhypertarget` is the +value of the `entrykey` field. + +A special formatting directive which controls the format of the +page/text portion in the argument of citation commands like `\volcite`. + +A special formatting directive which controls the format of the volume +portion in the argument of citation commands like `\volcite`. + +A special formatting directive which controls the format of `\printdate` +(??). Note that the date format (long/short etc.) is controlled by the +package option `date` from ??. This formatting directive only controls +additional formatting such as fonts etc. + +As `date` but controls the format of `\printlabeldate`. + +As `date` but controls the format of `\print<datetype>date`. + +A special formatting directive which controls the format of `\printtime` +(??). Note that the time format (24h/12h etc.) is controlled by the +package option `time` from ??. This formatting directive only controls +additional formatting such as fonts etc. + +As `time` but controls the format of `\printlabeltime`. + +As `time` but controls the format of `\print<datetype>time`. +]] + }, + strname = { + arguments = {{meta = "name list"}}, + details = [[ +```latex +\strname{name list} +``` + +Similar to `\thename`, except that the name internal representation is +automatically sanitized such that its value may safely be used in the +formation of a control sequence name. +]] + }, + subtitlepunct = { + details = [[ +```latex +\subtitlepunct +``` + +The separator printed between the fields `title` and `subtitle`, +`booktitle` and `booksubtitle`, as well as `maintitle` and +`mainsubtitle`. With the default styles, this separator replaces +`\newunitpunct` at this location. The default definition is +`\newunitpunct`, i.e. it is not handled differently from regular unit +punctuation. + +```latex +\subtitlepunct +``` + +The separator to be printed between the fields `title` and `subtitle`, +`booktitle` and `booksubtitle`, as well as `maintitle` and +`mainsubtitle`. Use this separator instead of `\newunitpunct` at this +location. The default is `\newunitpunct`, i.e. it is not handled +differently from regular unit punctuation but permits convenient +reconfiguration. +]] + }, + supercitedelim = { + details = [[ +```latex +\supercitedelim +``` + +Similar to `\multicitedelim`, but used by the `\supercite` command only. +The default is a comma. + +```latex +\supercitedelim +``` + +Similar to `\multinamedelim`, but intended for the `\supercite` command +only. The default is a comma. +]] + }, + supercitesubentrydelim = { + details = [[ +```latex +\supercitesubentrydelim +``` + +Analogue of `\multicitesubentrydelim` for `\supercite`. The default is +`\supercitedelim`. +]] + }, + texouterlang = { + arguments = {{meta = "text"}}, + details = [[ +```latex +\texouterlang{text} +``` + +Locally switches from the current language to the surrounding language +(which was not selected by `biblatex`) to typeset `text`. This can be +used the `wrapper` argument in the localisation string commands above. +]] + }, + textcite = { + action = "cite", + arguments = { + {delimiters = {"[", "]"}, meta = "prenote", optional = true}, + {delimiters = {"[", "]"}, meta = "postnote", optional = true}, + {meta = "key"} + }, + details = "$ref:biblatex.sty#/commands/Textcite/details" + }, + textnohyphenation = { + arguments = {{meta = "text"}}, + details = [[ +```latex +\textnohyphenation{text} +``` + +Similar to `\nohyphenation` but restricted to the `text` argument. +]] + }, + thefield = { + arguments = {{meta = "field"}}, + details = [[ +```latex +\thefield{field} +``` + +Expands to the unformatted `field`. If the `field` is undefined, this +command expands to an empty string. +]] + }, + thefirstlistitem = { + arguments = {{meta = "literal list"}}, + details = [[ +```latex +\thefirstlistitem{literal list} +``` + +Expands to the unformatted first item in `literal list`. If the +`literal list` is undefined, this command expands to an empty string. +]] + }, + thelist = { + arguments = {{meta = "literal list"}}, + details = [[ +```latex +\thelist{literal list} +``` + +Expands to the unformatted `literal list`. If the list is undefined, +this command expands to an empty string. Note that this command will +dump the `literal list` in the internal format used by this package. +This format is not suitable for printing. +]] + }, + translatortypedelim = { + details = [[ +```latex +\translatortypedelim +``` + +The delimiter printed between the translator and the `translator` +string. The default is a comma followed by a space. +]] + }, + translit = { + arguments = { + {delimiters = {"[", "]"}, meta = "langids", optional = true}, + {meta = "field or fieldset"}, + {meta = "from"}, + {meta = "to"} + }, + details = [=[ +```latex +\translit[langids]{field or fieldset}{from}{to} +``` + +Specifies that the data field `field` or all fields in a fieldset +`fieldset` declared with `\DeclareDatafieldSet` (see ??) should be +transliterated from script `from` to script `to` for sorting purposes. +The field/set argument should be <\*> to apply transliteration to +all fields. The valid `from` and `to` values are given in table +[\[tab:translit\]][1]. The optional `langids` parameter is a +comma-separated list of `langid` fields and the transliteration will +apply only to bibliography entries containing one of the `langid`s in +the list. Note that `biblatex`does not aim to support general +transliteration, only those which are useful for sorting purposes. +Please open a GitHub ticket for `biblatex` if you think you need +additional transliterations. + +An example of transliterating titles so that they sort correctly in +Sanskrit. This example assumes that entries that should have their title +fields transliterated have a `langid` field set to <sanskrit>. + + \DeclareDatafieldSet{settitles}{ + \member[field=title] + \member[field=booktitle] + \member[field=eventtitle] + \member[field=issuetitle] + \member[field=journaltitle] + \member[field=maintitle] + \member[field=origtitle] + } + + \DeclareSortTranslit{ + \translit[sanskrit]{settitles}{iast}{devanagari} + } + + [1]: #tab:translit +]=] + }, + uniquename = { + details = [[ +```latex +\uniquename +``` + +This counter refers to the `labelname` list. It is set on a per-name +basis. Its value is `0` if the base parts of the name (by default just +the <family> part of the name) are unique, `1` if adding the other +non-base parts of the name (as specified in the uniquename template +defined by `\DeclareUniquenameTemplate`) as initials will make it +unique, and `2` if adding the full form of the non-base parts of the +name are required to disambiguate the name. This information is required +by author-year and author-title citation schemes which add additional +parts of the name when citing different authors with the same family +name. For example, (given the default `\DeclareUniquenameTemplate` +definition) if there is one <John Doe> and one <Edward Doe> in the +list of references, this counter will be set to `1`. If there is one +<John Doe> and one <Jane Doe>, the value of the counter will be +`2`. If the option is set to `init`/`allinit`/`mininit`, the counter +will be limited to `1`. This is useful for citations styles which use +initials to disambiguate names but never print the full name in +citations. If adding the initials is not sufficient to disambiguate the +name, `uniquename` will also be set to `0` for that name. This feature +needs to be enabled explicitly with the package option `uniquename`. +Note that the `uniquename` counter is local to `\printnames` and that it +is only set for the `labelname` list and for the name list that +`labelname` has been derived from (typically `author` or `editor`). Its +value is zero in any other context, i.e., it must be evaluated in the +name formatting directives handling name lists. See ?? for further +details and practical examples. This counter can be overridden on a +per-namepart basis by consulting the `\namepart<namepart>un` macros +during name formatting, see ??. +]] + }, + unspace = { + details = [[ +```latex +\unspace +``` + +Removes preceding whitespace, i.e. removes all skips and penalties from +the end of the current horizontal list. This command is implicitly +executed by all of the following commands. +]] + }, + usebibmacro = { + arguments = {{literal = "*", optional = true}, {meta = "name"}}, + details = [[ +```latex +\usebibmacro*{name} +``` + +This command executes the macro `name`, as defined with `\newbibmacro`. +If the macro takes any arguments, they are simply appended after `name`. +The regular variant of this command sanitizes `name` while the starred +variant does not. +]] + }, + usefirstlistitem = { + arguments = {{meta = "command"}, {meta = "literal list"}}, + details = [[ +```latex +\usefirstlistitem{command}{literal list} +``` + +Executes `command` using the unformatted first item of `literal list` as +its argument. +]] + } +} +environments = { + refsection = { + arguments = { + { + delimiters = {"[", "]"}, + meta = "resource, ... ", + optional = true + } + }, + details = [[ +```latex +\begin{refsection}[resource, ... ] ... \end{refsection} +``` + +The optional argument is a comma-separated list of resources specific to +the reference section. If the argument is omitted, the reference section +will use the default resource list, as specified with `\addbibresource` +in the preamble. If the argument is provided, it replaces the default +resource list. Global resources specified with `\addglobalbib` are +always considered. `refsection` environments may not be nested, but you +may use `refsegment` environments within a `refsection` to subdivide it +into segments. Use the `section` option of `\printbibliography` to +select a section when printing the bibliography, and the corresponding +option of `\printbiblist` when printing bibliography lists. Bibliography +sections are numbered starting at `1`. The number of the current section +is also written to the transcript file. All citations given outside a +`refsection` environment are assigned to section 0. If +`\printbibliography` is used within a `refsection`, it will +automatically select the current section. The `section` option is not +required in this case. This also applies to `\printbiblist`. Beginning a +new reference section automatically ends the active reference context +(see ??). +]] + }, + refsegment = { + details = [[ +```latex +\begin{refsegment} ... \end{refsegment} +``` + +The difference between a `refsection` and a `refsegment` environment is +that the former creates labels which are local to the environment +whereas the latter provides a target for the `segment` filter of +`\printbibliography` without affecting the labels. They will be unique +across the entire document. `refsegment` environments may not be nested, +but you may use them in conjunction with `refsection` to subdivide a +reference section into segments. In this case, the segments are local to +the enclosing `refsection` environment. Use the `segment` option of +`\printbibliography` to select a segment when printing the bibliography. +Within a section, the reference segments are numbered starting at `1` +and the number of the current segment will be written to the transcript +file. All citations given outside a `refsegment` environment are +assigned to segment 0. In contrast to the `refsection` environment, the +current segment is not selected automatically if `\printbibliography` is +used within a `refsegment` environment. +]] + } +} |