# Templates
## Helpers
Yomichan supports several custom Handlebars helpers for rendering templates.
The source code for these templates can be found [here](../ext/js/templates/sandbox/anki-template-renderer.js).
### `dumpObject`
Converts an object to a pretty-printed JSON string.
This function can be helpful for debugging values when creating templates.
Syntax:
{{dumpObject object}}
* _`object`_
The object to convert.
Example:
```handlebars
{{dumpObject .}}
```
Output:
```html
{
"key": "value"
}
```
Preview:
```html
{
"key": "value"
}
```
### `furigana`
Converts a definition or expression/reading pair to its furigana representation.
Syntax:
{{furigana definition}}
{{furigana expression reading}}
* _`definition`_
The definition to convert.
* _`expression`_
The expression to convert.
* _`reading`_
The reading to convert.
Example:
```handlebars
{{furigana .}}
{{furigana "読む" "よむ"}}
```
Output:
```html
読む
```
Preview
読む
### `furiganaPlain`
Converts a definition or expression/reading pair to its simplified furigana representation.
Syntax:
{{furiganaPlain definition}}
{{furiganaPlain expression reading}}
* _`definition`_
The definition to convert.
* _`expression`_
The expression to convert.
* _`reading`_
The reading to convert.
Example:
```handlebars
{{~furiganaPlain .~}}
{{furiganaPlain "読む" "よむ"}}
```
Output:
```html
読[よ]む
```
### `multiLine`
Replaces newline characters with a forced HTML line break `
`.
Syntax:
{{#multiLine}}text with multiple lines{{/multiLine}}
Example:
```handlebars
{{#kanjiLinks~}}
some
multiline
text
{{~/kanjiLinks}}
```
Output:
```html
some
multiline
text
```
Preview:
some
multiline
text
### `regexReplace`
Uses a [regular expression](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions) to replace a pattern with the specified text.
Syntax:
{{#regexReplace regex replacement [flags]}}text-to-modify{{/regexReplace}}
{{#regexReplace regex replacement [flags] [text-to-modify]...}}{{/regexReplace}}
* _`regex`_
The raw string used to create the regular expression. This value is passed to the [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/RegExp) constructor.
* _`replacement`_
The text used to replace pattern matches. This supports the standard [special capture group replacements](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#Specifying_a_string_as_a_parameter) as supported by the web browser.
* _`flags`_ _(optional)_
Optional flags to pass to the [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/RegExp) constructor.
* _`text-to-modify`_
The text that the regular expression is applied to.
If multiple arguments are present, they are all concatenated.
Example:
```handlebars
{{#regexReplace "\(([^)]*)\)" "$1" "g"~}}Here is (some) (text) (in) (parentheses){{~/regexReplace}}
```
Output:
```html
Here is some text in parentheses
```
### `regexMatch`
Uses a [regular expression](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions) to return only the content that matches the pattern.
Syntax:
{{#regexMatch regex [flags]}}text-to-modify{{/regexMatch}}
{{#regexMatch regex [flags] [text-to-modify]...}}{{/regexMatch}}
* _`regex`_
The raw string used to create the regular expression. This value is passed to the [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/RegExp) constructor.
* _`flags`_ _(optional)_
Optional flags to pass to the [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/RegExp) constructor.
* _`text-to-modify`_
The text that the regular expression is applied to.
If multiple arguments are present, they are all concatenated.
Example:
```handlebars
{{#regexMatch "\(([^)]*)\)" "g"~}}Here is (some) (text) (in) (parentheses){{~/regexMatch}}
```
Output:
```html
(some)(text)(in)(parentheses)
```
### `mergeTags`
Creates a set of all unique tags for the definition and returns a text representation of the tags separated by commas.
Syntax:
{{#mergeTags definition isGroupMode isMergeMode}}{{/mergeTags}}
* _`definition`_
The root definition object.
* _`isGroupMode`_ _(optional)_
Whether or not the display mode is the 'group' mode.
* _`isMergeMode`_
Whether or not the display mode is the 'merge' mode.
Example:
```handlebars
{{~#mergeTags definition group merge}}{{/mergeTags~}}
```
Output:
```html
v5m, vt, JMdict (English)
```
### `eachUpTo`
Similar to the built-in `each` function, but iterates up to a maximum count.
If the iterable is falsy or empty, the `else` condition will be used.
Syntax:
{{#eachUpTo iterable maxCount}}(modification){{else}}(else-modification){{/eachUpTo}}
* _`iterable`_
The object that should be looped over. A JavaScript [`for...of`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of) loop is used, so the object only needs to be iterable.
* _`maxCount`_ _(optional)_
The maximum number of entries to loop over.
* _`modification`_
The template used to modify the value. The context is changed to the current item of iteration.
* _`else-modification`_
The template used in case the iterable is falsy or empty. The context is unchanged.
Example:
```handlebars
{{~#eachUpTo someArray 5}}{{{.}}}
{{else}}Empty{{/mergeTags~}}
```
Output:
```html
someArray[0]
someArray[1]
someArray[2]
someArray[3]
someArray[4]
```
Preview:
someArray[0]
someArray[1]
someArray[2]
someArray[3]
someArray[4]
### `spread`
Uses the JavaScript [spread](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax) operator to convert one or more iterables into a single array.
This allows it to be used similar to an [`Array.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat) operation.
Syntax:
{{#spread iterable1 iterable2 ... iterableN}}{{/spread}}
* _`iterableN`_
A variable amount of iterable objects to combine into a single array.
Example:
```handlebars
{{#each (spread array1 array2)}}{{{.}}}
{{/each}}
```
Output:
```html
array1[0]
array1[1]
array2[0]
array2[1]
```
Preview:
array1[0]
array1[1]
array2[0]
array2[1]
### `op`
Performs a simple operation on one, two, or three arguments. The operations available are:
* Unary operators: `+`, `-`, `~`, `!`
* Binary operators: `+`, `-`, `/`, `*`, `%`, `**`, `==`, `!=`, `===`, `!==`, `<`, `<=`, `>`, `>=`, `<<`, `>>`, `>>>`, `&`, `|`, `^`, `&&`, `||`
* Ternary operators: `?:`
If an unknown operator is specified, the `undefined` value is returned.
Syntax:
{{#op operator operand1 [operand2] [operand3]}}{{/op}}
* _`operator`_
One of the unary, binary, or ternary operators.
* _`operand1`_
The first operand of the operation.
* _`operand2`_ _(Optional)_
The second operand of the operation.
* _`operand3`_ _(Optional)_
The third operand of the operation.
Example:
```handlebars
{{#if (op "===" value1 value2)}}Values are equal{{/op~}}
{{~#op "-" value1}}{{/op~}}
{{~#op "?:" value1 "a" "b"}}{{/op}}
```
Output:
```html
Values are equal
-32
a
```
Preview:
Values are equal
-32
a
### `get`
Gets a value from the custom state stack.
Syntax:
{{#get name}}{{/get}}
* _`name`_
The name of the variable to get.
Example:
```handlebars
{{#get "some-text"}}{{/get}}
```
Output:
```html
This is the value of some-text!
```
### `set`
Assigns a value to the custom state stack.
Syntax:
{{#set name}}value{{/get}}
{{#set name value}}{{/get}}
* _`name`_
The name of the variable to assign.
* _`value`_
The value of the variable.
Example:
```handlebars
{{#set "some-text"}}This is the value of some-text!{{/set~}}
{{~#set "some-number" 32}}{{/set}}
```
Output:
```html
```
### `scope`
Pushes a new variable scope to the custom state stack.
Variable assignments are applied to the most recent scope,
and variable lookups will start from the most recent scope and work backwards until a value is found.
Syntax:
{{#scope}}content{{/scope}}
* _`name`_
The name of the variable to assign.
* _`value`_
The value of the variable.
Example:
```handlebars
{{~#set "key" 32}}{{/set~}}
{{~#get "key"}}{{/get~}},
{{~#scope~}}
{{~#get "key"}}{{/get~}},
{{~#set "key" 64}}{{/set~}}
{{~#get "key"}}{{/get~}},
{{~/scope~}}
{{~#get "key"}}{{/get~}}
```
Output:
```html
32,32,64,32
```
### `property`
Repeatedly gets a property of an object.
Syntax:
{{#property object property1 property2 ... propertyN}}{{/property}}
* _`object`_
The initial object to use.
* _`propertyN`_
A chain of property names to get on the object.
Example:
```handlebars
{{property someObject "field" 0 "toString"}}
```
Output:
```html
function toString() { [native code] }
```
### `noop`
No-op. Returns the inner contents of the template.
Syntax:
{{#noop}}content{{/noop}}
Example:
```handlebars
{{noop}}Unchanged content{{/noop}}
```
Output:
```html
Unchanged content
```
### `isMoraPitchHigh`
Returns whether or not a mora will have a high pitch, given the index of the mora and the position of the downstep.
Syntax:
{{#isMoraPitchHigh index position}}{{/isMoraPitchHigh}}
Example:
```handlebars
{{#if (isMoraPitchHigh 1 2)}}High pitch{{else}}Low pitch{{/if}}
```
Output:
```html
High pitch
```
### `getKanaMorae`
Returns an array of the mora for a kana string.
Syntax:
{{#getKanaMorae kana-string}}{{/getKanaMorae}}
Example:
```handlebars
{{#each (getKanaMorae "よみちゃん")}}{{{.}}}
{{/each}}
```
Output:
```html
よ
み
ちゃ
ん
```
Preview:
よ
み
ちゃ
ん
### `typeof`
Returns the type of a value.
Syntax:
{{#typeof value}}{{/typeof}}
{{#typeof}}value{{/typeof}}
* _`value`_
The value to check.
Example:
```handlebars
{{#typeof "よみちゃん"}}{{/typeof}}
{{#typeof 1}}{{/typeof}}
{{#typeof}}よみちゃん{{/typeof}}
```
Output:
```html
string
number
string
```
### `join`
Joins the arguments to a single string with a separator, flattening any arguments that are arrays.
Syntax:
{{#join separator value1 value2 valueN...}}{{/join}}
* _`separator`_
The separator string to use between values.
* _`valueN`_
An individual value to join into the resulting string
Example:
```handlebars
{{#set "index" 32}}{{/set~}}
{{~#join "_" "yomichan" (get "index") "value"}}{{/join}}
```
Output:
```html
yomichan_32_value
```
### `concat`
Joins the arguments to a single string, without flattening arguments that are arrays.
Syntax:
{{#concat value1 value1 valueN...}}{{/concat}}
* _`valueN`_
A value to join into the resulting string
Example:
```handlebars
{{#set "index" 32}}{{/set~}}
{{~#concat "yomichan_" (get "index") "_value"}}{{/concat}}
```
Output:
```html
yomichan_32_value
```
### `pitchCategories`
Returns an array representing the different pitch categories for a specific term.
Syntax:
{{#pitchCategories @root}}{{/pitchCategories}}
* _`@root`_
The argument passed should always be the root data object.
Example:
```handlebars
[{{#each (pitchCategories @root)}}{{.}}{{#unless @last}}, {{/unless}}{{/each}}]
```
Output:
```html
[heiban, kifuku]
```
### `formatGlossary`
Formats a glossary entry to a HTML content string. This helper handles image and
structured-content generation.
Syntax:
{{formatGlossary dictionary definitionEntry}}
* _`dictionary`_
The dictionary that the glossary entry belongs to.
* _`definitionEntry`_
The definition entry object in raw form.
Example:
```handlebars
{{#each glossary}}{{formatGlossary ../dictionary .}}{{/each}}
```
Output:
```html
Here is the content of a gloss, which may include formatted HTML.
```
### `hasMedia` & `getMedia`
Checks to see if a certain type of media is available for a card and injects the relevant content.
These functions are used together in order to request media and other types of optional asynchronous content.
Syntax:
{{#hasMedia type args...}}{{/hasMedia}}
{{#getMedia type args... [escape=true|false]}}{{/getMedia}}
* _`type`_
The type of media to check for.
* _`args`_
Additional arguments for the media. The arguments depend on the media type.
* _`escape`_ _(optional)_
Whether or not the resulting text should be HTML-escaped. If omitted, defaults to `true`.
**Available media types and arguments**
* "audio"
* "screenshot"
* "clipboardImage"
* "clipboardText"
* "selectionText"
* "textFurigana" japaneseText readingMode="default|hiragana|katakana"
* "dictionaryMedia" fileName dictionary="Dictionary Name"
Examples:
```handlebars
{{#if (hasMedia "audio")}}The audio file name is: {{#getMedia "audio"}}{{/getMedia}}{{/if}}
{{#if (hasMedia "screenshot")}}The screenshot file name is: {{#getMedia "screenshot"}}{{/getMedia}}{{/if}}
{{#if (hasMedia "clipboardImage")}}The clipboard image file name is: {{#getMedia "clipboardImage"}}{{/getMedia}}{{/if}}
{{#if (hasMedia "clipboardText")}}The clipboard text is: {{#getMedia "clipboardText"}}{{/getMedia}}{{/if}}
{{#if (hasMedia "selectionText")}}The selection text is: {{#getMedia "selectionText"}}{{/getMedia}}{{/if}}
{{#if (hasMedia "textFurigana" "日本語")}}This is an example of text with generated furigana: {{#getMedia "textFurigana" "日本語" escape=false}}{{/getMedia}}{{/if}}
{{#if (hasMedia "dictionaryMedia" "image.png" dictionary="Example Dictionary")}}The remapped file name for image.png is: {{#getMedia "dictionaryMedia" "image.png" dictionary="Example Dictionary"}}{{/getMedia}}{{/if}}
```
Output:
```html
The audio file name is: yomichan_audio_にほんご_日本語.mp3
The screenshot file name is: yomichan_browser_screenshot_にほんご_日本語.png
The clipboard image file name is: yomichan_clipboard_image_にほんご_日本語.png
The clipboard text is: This is the clipboard text
The selection text is: This is the selection text
The selection text is: This is the selection text
This is an example of text with generated furigana: 日本語
The remapped file name for image.png is: yomichan_dictionary_media_1_にほんご_日本語.png
```
### `pronunciation`
Converts pronunciation information into a formatted HTML content string. The display layout is the
same as the system used for generating popup and search page dictionary entries.
Syntax:
{{#pronunciation format=string reading=string downstepPosition=integer [nasalPositions=array] [devoicePositions=array]}}{{/pronunciation}}
* _`format`_
The format of the HTML to generate. This can be any of the following values:
* `'text'`
* `'graph'`
* `'position'`
* _`reading`_
The kana reading of the term.
* _`downstepPosition`_
The mora position of the downstep in the reading.
* _`nasalPositions`_ _(optional)_
An array of indices of mora that have a nasal pronunciation.
* _`devoicePositions`_ _(optional)_
An array of indices of mora that are devoiced.
Example:
```handlebars
{{~#pronunciation format='text' reading='よむ' downstepPosition=1~}}{{~/pronunciation~}}
```
### `hiragana`
Converts katakana text to hiragana.
Syntax:
{{#hiragana value [keepProlongedSoundMarks=true|false]}}{{/hiragana}}
{{#hiragana [keepProlongedSoundMarks=true|false]}}value{{/hiragana}}
* _`value`_
The text to convert.
* _`keepProlongedSoundMarks`_ _(optional)_
Whether or not the `ー` character should be kept or converted to a vowel character.
Defaults to `false` if not specified.
Example:
```handlebars
{{#hiragana "よみちゃん ヨミちゃん ヨミチャン"}}{{/hiragana}}
{{#hiragana}}よみちゃん ヨミちゃん ヨミチャン{{/hiragana}}
{{#hiragana}}ローマ字{{/hiragana}}
{{#hiragana keepProlongedSoundMarks=true}}ローマ字{{/hiragana}}
```
Output:
```html
よみちゃん よみちゃん よみちゃん
よみちゃん よみちゃん よみちゃん
ろうま字
ろーま字
```
### `katakana`
Converts hiragana text to katakana.
Syntax:
{{#katakana text}}{{/katakana}}
{{#katakana}}text{{/katakana}}
* _`text`_
The text to convert.
Example:
```handlebars
{{#katakana "よみちゃん ヨミちゃん ヨミチャン"}}{{/katakana}}
{{#katakana}}よみちゃん ヨミちゃん ヨミチャン{{/katakana}}
```
Output:
```html
ヨミチャン ヨミチャン ヨミチャン
ヨミチャン ヨミチャン ヨミチャン
```
## Legacy Helpers
Yomichan has historically used Handlebars templates to generate the HTML used on the search page and results popup.
To simplify the and improve Yomichan's capabilities, the HTML elements are now generated directly using a different process.
As such, there are several leftover Handlebars helpers that do not have much utility for Anki templates, but are kept for compatibility purposes.
### `kanjiLinks`
Replaces kanji characters in the text with linkified versions.
Syntax:
{{#kanjiLinks}}text{{/kanjiLinks}}
Example:
```handlebars
{{#kanjiLinks}}読む{{/kanjiLinks}}
```
Output:
```html
読む
```
Preview:
読む
### `sanitizeCssClass`
Sanitizes text so it can be used as a CSS class name.
Syntax:
{{#sanitizeCssClass}}text{{/sanitizeCssClass}}
Example:
```handlebars
{{#sanitizeCssClass}}some text with many types of characters !@#$%^ 読む{{/sanitizeCssClass}}
```
Output:
```html
some_text_with_many_types_of_characters________読む
```