yomitan-core 1.2.0 → 1.3.0

package/dist/anki.cjs

@@ -6,7 +6,10 @@ const require_errors = require('./errors-0pIJI6N2.cjs');
 const require_dictionary_data_util = require('./dictionary-data-util-DmLJMtGc.cjs');
 require('./json-Cdj6aIOQ.cjs');
 require('./furigana-SZuBaUyl.cjs');
+require('./text-utilities-CTsN1Bq8.cjs');
 const require_anki_connect = require('./anki-connect-DGx7Gr0H.cjs');
+const require_content_manager = require('./content-manager-BF1w7O_T.cjs');
+const require_structured_content_generator = require('./structured-content-generator-D3WOq_vz.cjs');
 
 //#region src/anki/anki-note-builder.ts
 /**
@@ -742,7 +745,7 @@ function getTermDictionaryAliases(dictionaryEntry) {
 	for (const { dictionaryAlias } of dictionaryEntry.definitions) dictionaryAliases.add(dictionaryAlias);
 	return [...dictionaryAliases];
 }
-function getTermDictionaryEntryCommonInfo(dictionaryEntry, type, _dictionaryStylesMap, _glossaryLayoutMode) {
+function getTermDictionaryEntryCommonInfo(dictionaryEntry, type, dictionaryStylesMap, _glossaryLayoutMode) {
 	const merged = type === "termMerged";
 	const hasDefinitions = type !== "term";
 	const allTermsSet = new Set();
@@ -756,6 +759,13 @@ function getTermDictionaryEntryCommonInfo(dictionaryEntry, type, _dictionaryStyl
 	const definitions = [];
 	const definitionTags = [];
 	for (const { tags, headwordIndices, entries, dictionary, dictionaryAlias, sequences } of dictionaryEntry.definitions) {
+		const dictionaryStyles = dictionaryStylesMap.get(dictionary);
+		let glossaryScopedStyles = "";
+		let dictScopedStyles = "";
+		if (dictionaryStyles) {
+			glossaryScopedStyles = addGlossaryScopeToCss(dictionaryStyles);
+			dictScopedStyles = addGlossaryScopeToCss(addDictionaryScopeToCss(dictionaryStyles, dictionary));
+		}
 		const definitionTags2 = [];
 		for (const tag of tags) {
 			definitionTags.push(convertTag(tag));
@@ -767,8 +777,8 @@ function getTermDictionaryEntryCommonInfo(dictionaryEntry, type, _dictionaryStyl
 			sequence: sequences[0],
 			dictionary,
 			dictionaryAlias,
-			glossaryScopedStyles: "",
-			dictScopedStyles: "",
+			glossaryScopedStyles,
+			dictScopedStyles,
 			glossary: entries,
 			definitionTags: definitionTags2,
 			only
@@ -960,13 +970,29 @@ function getTermGlossaryArray(dictionaryEntry, type) {
 	}
 	return void 0;
 }
-function getTermStyles(dictionaryEntry, type, _dictionaryStylesMap) {
+function getTermStyles(dictionaryEntry, type, dictionaryStylesMap) {
 	if (type !== "term") return void 0;
+	let glossaryScopedStyles = "";
+	let dictScopedStyles = "";
+	for (const { dictionary } of dictionaryEntry.definitions) {
+		const dictionaryStyles = dictionaryStylesMap.get(dictionary);
+		if (dictionaryStyles) {
+			glossaryScopedStyles += addGlossaryScopeToCss(dictionaryStyles);
+			dictScopedStyles += addGlossaryScopeToCss(addDictionaryScopeToCss(dictionaryStyles, dictionary));
+		}
+	}
 	return {
-		glossaryScopedStyles: "",
-		dictScopedStyles: ""
+		glossaryScopedStyles,
+		dictScopedStyles
 	};
 }
+function addGlossaryScopeToCss(css) {
+	return require_content_manager.addScopeToCssLegacy(css, ".yomitan-glossary");
+}
+function addDictionaryScopeToCss(css, dictionaryTitle) {
+	const escapedTitle = dictionaryTitle.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+	return require_content_manager.addScopeToCssLegacy(css, `[data-dictionary="${escapedTitle}"]`);
+}
 function getTermTags(dictionaryEntry, type) {
 	if (type !== "termMerged") {
 		const results = [];
@@ -1303,6 +1329,7 @@ var AnkiTemplateRenderer = class {
 	_stateStack;
 	_requirements;
 	_cleanupCallbacks;
+	_document;
 	_handlebars;
 	constructor(handlebars) {
 		this._handlebars = handlebars;
@@ -1311,6 +1338,7 @@ var AnkiTemplateRenderer = class {
 		this._stateStack = null;
 		this._requirements = null;
 		this._cleanupCallbacks = [];
+		this._document = typeof document !== "undefined" ? document : null;
 	}
 	/**
 	* Gets the core TemplateRenderer instance.
@@ -1345,6 +1373,7 @@ var AnkiTemplateRenderer = class {
 			["concat", this._concat.bind(this)],
 			["pitchCategories", this._pitchCategories.bind(this)],
 			["formatGlossary", this._formatGlossary.bind(this)],
+			["formatGlossaryPlain", this._formatGlossaryPlain.bind(this)],
 			["hasMedia", this._hasMedia.bind(this)],
 			["getMedia", this._getMedia.bind(this)],
 			["hiragana", this._hiragana.bind(this)],
@@ -1661,10 +1690,69 @@ var AnkiTemplateRenderer = class {
 		switch (content.type) {
 			case "text": return this._safeString(this._stringToMultiLineHtml(content.text));
 			case "image": return "";
-			case "structured-content": return this._safeString("[structured content]");
+			case "structured-content": return this._safeString(this._formatStructuredContent(content, _dictionary));
 		}
 		return "";
 	}
+	_formatGlossaryPlain(args) {
+		const [_dictionary, content] = args;
+		if (typeof content === "string") return this._safeString(content);
+		if (!(typeof content === "object" && content !== null)) return "";
+		switch (content.type) {
+			case "text": return this._safeString(content.text);
+			case "image": return "";
+			case "structured-content": return this._safeString(this._extractStructuredContentText(content.content));
+		}
+		return "";
+	}
+	_formatStructuredContent(content, dictionary) {
+		const node = this._createStructuredContentNode(content.content, dictionary);
+		if (node === null) return this._stringToMultiLineHtml(this._extractStructuredContentText(content.content));
+		return this._getNodeHtml(node);
+	}
+	_createStructuredContentNode(content, dictionary) {
+		if (this._document === null) return null;
+		const generator = new require_structured_content_generator.StructuredContentGenerator(new require_content_manager.NoOpContentManager(), this._document);
+		return generator.createStructuredContent(content, dictionary);
+	}
+	_getNodeHtml(node) {
+		if (this._document === null) return "";
+		const container = this._document.createElement("div");
+		container.appendChild(node);
+		return container.innerHTML;
+	}
+	_extractStructuredContentText(content) {
+		const text = this._extractStructuredContentTextParts(content).join("");
+		return text.replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").replace(/[ \t]{2,}/g, " ").trim();
+	}
+	_extractStructuredContentTextParts(content) {
+		if (typeof content === "string") return [content];
+		if (Array.isArray(content)) {
+			const parts = [];
+			for (const item of content) parts.push(...this._extractStructuredContentTextParts(item));
+			return parts;
+		}
+		if (!(typeof content === "object" && content !== null)) return [];
+		if (content.tag === "br") return ["\n"];
+		if (content.tag === "rt" || content.tag === "rp") return [];
+		const inner = typeof content.content !== "undefined" ? this._extractStructuredContentTextParts(content.content) : [];
+		switch (content.tag) {
+			case "li": return [...inner, "\n"];
+			case "td":
+			case "th": return [...inner, " "];
+			case "div":
+			case "ol":
+			case "ul":
+			case "table":
+			case "thead":
+			case "tbody":
+			case "tfoot":
+			case "tr":
+			case "details":
+			case "summary": return [...inner, "\n"];
+			default: return inner;
+		}
+	}
 	_hasMedia(args, _context, options) {
 		const data = this._getNoteDataFromOptions(options);
 		return this._mediaProvider.hasMedia(data, args, options.hash);
@@ -1748,12 +1836,711 @@ function getPitchCategory(reading, positions, isVerbOrAdjective) {
 	return isVerbOrAdjective ? "kifuku" : "nakadaka";
 }
 
+//#endregion
+//#region src/anki/default-anki-field-templates.ts
+const DEFAULT_ANKI_FIELD_TEMPLATES = String.raw`
+{{#*inline "glossary-single"}}
+    {{~#unless brief~}}
+        {{~#scope~}}
+            {{~set "any" false~}}
+            {{~#each definitionTags~}}
+                {{~#if (op "||" (op "!" @root.compactTags) (op "!" redundant))~}}
+                    {{~#if (get "any")}}, {{else}}<i>({{/if~}}
+                    {{name}}
+                    {{~set "any" true~}}
+                {{~/if~}}
+            {{~/each~}}
+            {{~#unless noDictionaryTag~}}
+                {{~#if (op "||" (op "!" @root.compactTags) (op "!==" dictionary (get "previousDictionary")))~}}
+                    {{~#if (get "any")}}, {{else}}<i>({{/if~}}
+                    {{dictionaryAlias}}
+                    {{~set "any" true~}}
+                {{~/if~}}
+            {{~/unless~}}
+            {{~#if (get "any")}})</i> {{/if~}}
+        {{~/scope~}}
+        {{~#if only~}}({{#each only}}{{.}}{{#unless @last}}, {{/unless}}{{/each}} only) {{/if~}}
+    {{~/unless~}}
+    {{~#if (op "<=" glossary.length 1)~}}
+        {{#each glossary}}{{formatGlossary ../dictionary .}}{{/each}}
+    {{~else if @root.compactGlossaries~}}
+        {{#each glossary}}{{formatGlossary ../dictionary .}}{{#unless @last}} | {{/unless}}{{/each}}
+    {{~else~}}
+        <ul>{{#each glossary}}<li>{{formatGlossary ../dictionary .}}</li>{{/each}}</ul>
+    {{~/if~}}
+    {{~set "previousDictionary" dictionary~}}
+{{/inline}}
+
+{{#*inline "audio"}}
+    {{~#if (hasMedia "audio")~}}
+        [sound:{{getMedia "audio"}}]
+    {{~/if~}}
+{{/inline}}
+
+{{#*inline "character"}}
+    {{~definition.character~}}
+{{/inline}}
+
+{{#*inline "dictionary"}}
+    {{~definition.dictionary~}}
+{{/inline}}
+
+{{#*inline "dictionary-alias"}}
+    {{~definition.dictionaryAlias~}}
+{{/inline}}
+
+{{#*inline "expression"}}
+    {{~#if merge~}}
+        {{~#each definition.expression~}}
+            {{{.}}}
+            {{~#unless @last}}、{{/unless~}}
+        {{~/each~}}
+    {{~else~}}
+        {{definition.expression}}
+    {{~/if~}}
+{{/inline}}
+
+{{#*inline "furigana"}}
+    {{~#if merge~}}
+        {{~#each definition.expressions~}}
+            <span class="expression-{{termFrequency}}">{{~furigana .~}}</span>
+            {{~#unless @last}}、{{/unless~}}
+        {{~/each~}}
+    {{~else~}}
+        {{furigana definition}}
+    {{~/if~}}
+{{/inline}}
+
+{{#*inline "furigana-plain"}}
+    {{~#if merge~}}
+        {{~#each definition.expressions~}}
+            <span class="expression-{{termFrequency}}">{{~furiganaPlain .~}}</span>
+            {{~#unless @last}}、{{/unless~}}
+        {{~/each~}}
+    {{~else~}}
+        {{furiganaPlain definition}}
+    {{~/if~}}
+{{/inline}}
+
+{{~#*inline "glossary"~}}
+    <div style="text-align: left;" class="yomitan-glossary">
+    {{~#scope~}}
+        {{~#if (op "===" definition.type "term")~}}
+            {{~#unless (op "&&" selectedDictionary (op "!=" selectedDictionary definition.dictionary))~}}
+                {{~> glossary-single definition brief=brief noDictionaryTag=noDictionaryTag ~}}
+                {{~#if definition.glossaryScopedStyles~}}
+                    <style>{{{definition.glossaryScopedStyles}}}</style>
+                {{~/if~}}
+            {{~/unless~}}
+        {{~else if (op "||" (op "===" definition.type "termGrouped") (op "===" definition.type "termMerged"))~}}
+            <ol>
+                {{~#each definition.definitions~}}
+                    {{~#unless (op "&&" ../selectedDictionary (op "!=" ../selectedDictionary dictionary))~}}
+                        <li data-dictionary="{{dictionary}}">
+                            {{~> glossary-single . brief=../brief noDictionaryTag=../noDictionaryTag ~}}
+                        </li>
+                        {{~#if dictScopedStyles~}}
+                            <style>{{{dictScopedStyles}}}</style>
+                        {{~/if~}}
+                    {{~/unless~}}
+                {{~/each~}}
+            </ol>
+        {{~else if (op "===" definition.type "kanji")~}}
+            {{~#if (op ">" definition.glossary.length 1)~}}
+                <ol>{{#each definition.glossary}}<li>{{.}}</li>{{/each}}</ol>
+            {{~else~}}
+                {{~#each definition.glossary~}}{{.}}{{~/each~}}
+            {{~/if~}}
+        {{~/if~}}
+    {{~/scope~}}
+    </div>
+{{~/inline~}}
+
+{{#*inline "glossary-no-dictionary"}}
+    {{~> glossary noDictionaryTag=true ~}}
+{{/inline}}
+
+{{#*inline "glossary-brief"}}
+    {{~> glossary brief=true ~}}
+{{/inline}}
+
+{{~#*inline "glossary-plain"~}}
+    {{~#scope~}}
+        {{~#if (op "||" (op "===" definition.type "termGrouped") (op "===" definition.type "termMerged"))~}}
+            {{~#each definition.definitions~}}
+                {{~#unless (op "&&" ../selectedDictionary (op "!=" ../selectedDictionary dictionary))~}}
+                    {{~#unless ../noDictionaryTag~}}
+                        ({{dictionaryAlias}})<br>
+                    {{~/unless~}}
+                    {{#each glossary}}{{{formatGlossaryPlain ../dictionary .}}}{{#unless @last}}<br>{{/unless}}{{/each}}{{#unless @last}}<br>{{/unless}}
+                {{~/unless~}}
+            {{~/each~}}
+        {{~else~}}
+            {{~#unless (op "&&" selectedDictionary (op "!=" selectedDictionary definition.dictionary))~}}
+                {{~#unless noDictionaryTag~}}
+                    ({{definition.dictionaryAlias}})<br>
+                {{~/unless~}}
+                {{#each definition.glossary}}{{{formatGlossaryPlain ../definition.dictionary .}}}{{/each}}
+            {{~/unless~}}
+        {{~/if~}}
+    {{~/scope~}}
+{{~/inline~}}
+
+{{#*inline "glossary-plain-no-dictionary"~}}
+    {{~> glossary-plain noDictionaryTag=true ~}}
+{{/inline}}
+
+{{~#*inline "glossary-first"~}}
+    <div style="text-align: left;" class="yomitan-glossary">
+    {{~#scope~}}
+        {{~#if (op "===" definition.type "term")~}}
+            {{~> glossary-single definition brief=brief noDictionaryTag=noDictionaryTag ~}}
+            {{~#if definition.glossaryScopedStyles~}}
+                <style>{{{definition.glossaryScopedStyles}}}</style>
+            {{~/if~}}
+        {{~else if (op "||" (op "===" definition.type "termGrouped") (op "===" definition.type "termMerged"))~}}
+            {{~#if (op ">" definition.definitions.length 1)~}}
+                {{~#with definition.definitions.[0]~}}
+                    {{~> glossary-single . brief=../brief noDictionaryTag=../noDictionaryTag ~}}
+                    {{~#if glossaryScopedStyles~}}
+                        <style>{{{glossaryScopedStyles}}}</style>
+                    {{~/if~}}
+                {{~/with~}}
+            {{~else~}}
+                {{~#with definition.definitions.[0]~}}
+                    {{~> glossary-single . brief=../brief noDictionaryTag=../noDictionaryTag ~}}
+                    {{~#if glossaryScopedStyles~}}
+                        <style>{{{glossaryScopedStyles}}}</style>
+                    {{~/if~}}
+                {{~/with~}}
+            {{~/if~}}
+        {{~/if~}}
+    {{~/scope~}}
+    </div>
+{{~/inline~}}
+
+{{#*inline "glossary-first-no-dictionary"}}
+    {{~> glossary-first noDictionaryTag=true ~}}
+{{/inline}}
+
+{{#*inline "glossary-first-brief"}}
+    {{~> glossary-first brief=true ~}}
+{{/inline}}
+
+{{#*inline "kunyomi"}}
+    {{~#each definition.kunyomi}}{{.}}{{#unless @last}}, {{/unless}}{{/each~}}
+{{/inline}}
+
+{{#*inline "onyomi"}}
+    {{~#each definition.onyomi}}{{.}}{{#unless @last}}, {{/unless}}{{/each~}}
+{{/inline}}
+
+{{#*inline "onyomi-hiragana"}}
+    {{~#each definition.onyomi}}{{hiragana .}}{{#unless @last}}, {{/unless}}{{/each~}}
+{{/inline}}
+
+{{#*inline "reading"}}
+    {{~#if merge~}}
+        {{~#each definition.reading~}}
+            {{{.}}}
+            {{~#unless @last}}、{{/unless~}}
+        {{~/each~}}
+    {{~else~}}
+        {{~definition.reading~}}
+    {{~/if~}}
+{{/inline}}
+
+{{#*inline "sentence"}}
+    {{~#if definition.cloze}}{{{definition.cloze.sentence}}}{{/if~}}
+{{/inline}}
+
+{{#*inline "cloze-prefix"}}
+    {{~#if definition.cloze}}{{{definition.cloze.prefix}}}{{/if~}}
+{{/inline}}
+
+{{#*inline "cloze-body"}}
+    {{~#if definition.cloze}}{{{definition.cloze.body}}}{{/if~}}
+{{/inline}}
+
+{{#*inline "cloze-body-kana"}}
+    {{~#if definition.cloze}}{{{definition.cloze.bodyKana}}}{{/if~}}
+{{/inline}}
+
+{{#*inline "cloze-suffix"}}
+    {{~#if definition.cloze}}{{{definition.cloze.suffix}}}{{/if~}}
+{{/inline}}
+
+{{#*inline "tags"}}
+    {{~#mergeTags definition group merge}}{{this}}{{/mergeTags~}}
+{{/inline}}
+
+{{~#*inline "url"~}}
+    <a href="{{definition.url}}">{{definition.url}}</a>
+{{~/inline~}}
+
+{{#*inline "screenshot"}}
+    {{~#if (hasMedia "screenshot")~}}
+        <img src="{{getMedia "screenshot"}}" />
+    {{~/if~}}
+{{/inline}}
+
+{{#*inline "document-title"}}
+    {{~context.document.title~}}
+{{/inline}}
+
+{{! Pitch Accents }}
+{{#*inline "pitch-accent-item"}}
+    {{~pronunciation format=format reading=reading pitchPositions=positions nasalPositions=nasalPositions devoicePositions=devoicePositions~}}
+{{/inline}}
+
+{{#*inline "pitch-accent-item-disambiguation"}}
+    {{~#scope~}}
+        {{~set "exclusive" (spread exclusiveExpressions exclusiveReadings)~}}
+        {{~#if (op ">" (property (get "exclusive") "length") 0)~}}
+            {{~set "separator" ""~}}
+            <em>({{#each (get "exclusive")~}}
+                {{~get "separator"~}}{{{.}}}
+            {{~/each}} only) </em>
+        {{~/if~}}
+    {{~/scope~}}
+{{/inline}}
+
+{{#*inline "pitch-accent-list"}}
+    {{~#if (op ">" pitchCount 0)~}}
+        {{~#if (op ">" pitchCount 1)~}}<ol>{{~/if~}}
+        {{~#each pitches~}}
+            {{~#each pitches~}}
+                {{~#if (op ">" ../../pitchCount 1)~}}<li>{{~/if~}}
+                    {{~> pitch-accent-item-disambiguation~}}
+                    {{~> pitch-accent-item format=../../format~}}
+                {{~#if (op ">" ../../pitchCount 1)~}}</li>{{~/if~}}
+            {{~/each~}}
+        {{~/each~}}
+        {{~#if (op ">" pitchCount 1)~}}</ol>{{~/if~}}
+    {{~/if~}}
+{{/inline}}
+
+{{#*inline "pitch-accents"}}
+    {{~> pitch-accent-list format='text'~}}
+{{/inline}}
+
+{{#*inline "pitch-accent-graphs"}}
+    {{~> pitch-accent-list format='graph'~}}
+{{/inline}}
+
+{{#*inline "pitch-accent-graphs-jj"}}
+    {{~> pitch-accent-list format='graph-jj'~}}
+{{/inline}}
+
+{{#*inline "pitch-accent-positions"}}
+    {{~> pitch-accent-list format='position'~}}
+{{/inline}}
+
+{{~#*inline "pitch-accent-categories"~}}
+    {{~#each (pitchCategories @root)~}}{{~.~}}{{~#unless @last~}},{{~/unless~}}{{~/each~}}
+{{~/inline~}}
+{{! End Pitch Accents }}
+
+{{#*inline "phonetic-transcriptions"}}
+    {{~#if (op ">" definition.phoneticTranscriptions.length 0)~}}
+        <ul>
+            {{~#each definition.phoneticTranscriptions~}}
+                {{~#each phoneticTranscriptions~}}
+                    <li class="pronunciation" data-pronunciation-type="phonetic-transcription">
+                        {{~set "any" false~}}
+                        {{~#each tags~}}
+                            {{~#if (get "any")}}, {{else}}<i>({{/if~}}
+                            <span class="tag" data-details="{{name}}">{{name}}</span>
+                            {{~set "any" true~}}
+                        {{~/each~}}
+                        {{~#if (get "any")}})</i> {{/if~}}
+                        {{ipa~}}
+                    </li>
+                {{~/each~}}
+            {{~/each~}}
+        </ul>
+    {{~/if~}}
+{{/inline}}
+
+{{#*inline "clipboard-image"}}
+    {{~#if (hasMedia "clipboardImage")~}}
+        <img src="{{getMedia "clipboardImage"}}" />
+    {{~/if~}}
+{{/inline}}
+
+{{#*inline "clipboard-text"}}
+    {{~#if (hasMedia "clipboardText")}}{{{getMedia "clipboardText"}}}{{/if~}}
+{{/inline}}
+
+{{#*inline "conjugation"}}
+    {{~#if (op ">" definition.inflectionRuleChainCandidates.length 0)~}}
+        {{~set "multiple" false~}}
+        {{~#if (op ">" definition.inflectionRuleChainCandidates.length 1)~}}
+            {{~set "multiple" true~}}
+        {{~/if~}}
+        {{~#if (get "multiple")~}}<ul>{{/if~}}
+            {{~#each definition.inflectionRuleChainCandidates~}}
+                {{~#if (op ">" inflectionRules.length 0)~}}
+                    {{~#if (get "multiple")~}}<li>{{/if~}}
+                    {{~#each inflectionRules~}}
+                        {{~#if (op ">" @index 0)}} « {{/if~}}
+                        {{name}}
+                    {{~/each~}}
+                    {{~#if (get "multiple")~}}</li>{{/if~}}
+                {{~/if~}}
+            {{~/each~}}
+        {{~#if (get "multiple")~}}</ul>{{/if~}}
+    {{~/if~}}
+{{/inline}}
+
+{{#*inline "frequencies"}}
+    {{~#if (op ">" definition.frequencies.length 0)~}}
+        <ul style="text-align: left;">
+        {{~#each definition.frequencies~}}
+            {{~#unless (op "&&" ../selectedDictionary (op "!=" ../selectedDictionary dictionary))~}}
+                <li>
+                {{~#if (op "!==" ../definition.type "kanji")~}}
+                    {{~#if (op "||" (op ">" ../uniqueExpressions.length 1) (op ">" ../uniqueReadings.length 1))~}}(
+                        {{~furigana expression reading~}}
+                    ) {{/if~}}
+                {{~/if~}}
+                {{~dictionaryAlias}}: {{frequency~}}
+                </li>
+            {{~/unless~}}
+        {{~/each~}}
+        </ul>
+    {{~/if~}}
+{{/inline}}
+
+{{#*inline "single-frequency-number"}}
+    {{~#if (op ">" definition.frequencyNumbers.length 0)~}}
+        {{~#each definition.frequencyNumbers~}}
+            {{~#unless (op "&&" ../selectedDictionary (op "!=" ../selectedDictionary dictionary))~}}
+                    {{frequency~}}
+            {{~/unless~}}
+        {{~/each~}}
+    {{/if}}
+{{/inline}}
+
+{{#*inline "frequency-harmonic-rank"}}
+    {{~#if (op "===" definition.frequencyHarmonic -1) ~}}
+        9999999
+    {{~else ~}}
+        {{definition.frequencyHarmonic}}
+    {{~/if~}}
+{{/inline}}
+
+{{#*inline "frequency-harmonic-occurrence"}}
+    {{~#if (op "===" definition.frequencyHarmonic -1) ~}}
+        0
+    {{~else ~}}
+        {{definition.frequencyHarmonic}}
+    {{~/if~}}
+{{/inline}}
+
+{{#*inline "frequency-average-rank"}}
+    {{~#if (op "===" definition.frequencyAverage -1) ~}}
+        9999999
+    {{~else ~}}
+        {{definition.frequencyAverage}}
+    {{~/if~}}
+{{/inline}}
+
+{{#*inline "frequency-average-occurrence"}}
+    {{~#if (op "===" definition.frequencyAverage -1) ~}}
+        0
+    {{~else ~}}
+        {{definition.frequencyAverage}}
+    {{~/if~}}
+{{/inline}}
+
+{{#*inline "stroke-count"}}
+    {{~#scope~}}
+        {{~set "found" false~}}
+        {{~#each definition.stats.misc~}}
+            {{~#if (op "===" name "strokes")~}}
+                {{~set "found" true~}}
+                Stroke count: {{value}}
+            {{~/if~}}
+        {{~/each~}}
+        {{~#if (op "!" (get "found"))~}}
+            Stroke count: Unknown
+        {{~/if~}}
+    {{~/scope~}}
+{{/inline}}
+
+{{#*inline "part-of-speech-pretty"}}
+    {{~#if (op "===" . "v1")~}}Ichidan verb
+    {{~else if (op "===" . "v5")~}}Godan verb
+    {{~else if (op "===" . "vk")~}}Kuru verb
+    {{~else if (op "===" . "vs")~}}Suru verb
+    {{~else if (op "===" . "vz")~}}Zuru verb
+    {{~else if (op "===" . "adj-i")~}}I-adjective
+    {{~else if (op "===" . "n")~}}Noun
+    {{~else~}}{{.}}
+    {{~/if~}}
+{{/inline}}
+
+{{#*inline "part-of-speech"}}
+    {{~#scope~}}
+        {{~#if (op "!==" definition.type "kanji")~}}
+            {{~set "first" true~}}
+            {{~#each definition.expressions~}}
+                {{~#each wordClasses~}}
+                    {{~#unless (get (concat "used_" .))~}}
+                        {{~> part-of-speech-pretty . ~}}
+                        {{~#unless (get "first")}}, {{/unless~}}
+                        {{~set (concat "used_" .) true~}}
+                        {{~set "first" false~}}
+                    {{~/unless~}}
+                {{~/each~}}
+            {{~/each~}}
+            {{~#if (get "first")~}}Unknown{{~/if~}}
+        {{~/if~}}
+    {{~/scope~}}
+{{/inline}}
+
+{{#*inline "search-query"}}
+    {{~#multiLine}}{{context.fullQuery}}{{/multiLine~}}
+{{/inline}}
+
+{{#*inline "popup-selection-text"}}
+    {{~#if (hasMedia "popupSelectionText")}}{{{getMedia "popupSelectionText"}}}{{/if~}}
+{{/inline}}
+
+{{#*inline "sentence-furigana"}}
+    {{~#if definition.cloze~}}
+        {{~#if (hasMedia "textFurigana" definition.cloze.sentence)~}}
+            {{{getMedia "textFurigana" definition.cloze.sentence escape=false}}}
+        {{~else~}}
+            {{{definition.cloze.sentence}}}
+        {{~/if~}}
+    {{~/if~}}
+{{/inline}}
+
+{{#*inline "sentence-furigana-plain"}}
+    {{~#if definition.cloze~}}
+        {{~#if (hasMedia "textFuriganaPlain" definition.cloze.sentence)~}}
+            {{{getMedia "textFuriganaPlain" definition.cloze.sentence escape=false}}}
+        {{~else~}}
+            {{{definition.cloze.sentence}}}
+        {{~/if~}}
+    {{~/if~}}
+{{/inline}}
+
+{{~> (lookup . "marker") ~}}
+`;
+
+//#endregion
+//#region src/anki/anki-note-service.ts
+async function resolveDefaultHandlebars() {
+	try {
+		const module$1 = await import("yomitan-handlebars");
+		return module$1.default ?? module$1;
+	} catch {
+		const module$1 = await import("handlebars");
+		return module$1.default ?? module$1;
+	}
+}
+async function createDefaultAnkiTemplateRenderer(handlebars) {
+	const handlebarsInstance = handlebars ?? await resolveDefaultHandlebars();
+	const renderer = new AnkiTemplateRenderer(handlebarsInstance);
+	await renderer.prepare();
+	return renderer;
+}
+function getDefaultAnkiFieldTemplates(dynamicTemplates = "") {
+	const template = DEFAULT_ANKI_FIELD_TEMPLATES.trim();
+	const trimmedDynamicTemplates = dynamicTemplates.trim();
+	if (trimmedDynamicTemplates.length === 0) return template;
+	const markerSnippet = "{{~> (lookup . \"marker\") ~}}";
+	const markerIndex = template.lastIndexOf(markerSnippet);
+	if (markerIndex < 0) return `${template}\n${trimmedDynamicTemplates}`;
+	const before = template.slice(0, markerIndex).trimEnd();
+	const after = template.slice(markerIndex);
+	return `${before}\n\n${trimmedDynamicTemplates}\n\n${after}`;
+}
+async function buildAnkiNoteFromDictionaryEntry(input, handlebars) {
+	const renderer = await createDefaultAnkiTemplateRenderer(handlebars);
+	const templateRenderer = renderer.templateRenderer;
+	const builder = new AnkiNoteBuilder({
+		getModifiedData: async (data, type) => templateRenderer.getModifiedData(data, type),
+		renderMulti: async (items) => templateRenderer.renderMulti(items)
+	});
+	return await builder.createNote({
+		dictionaryEntry: input.dictionaryEntry,
+		cardFormat: input.cardFormat,
+		context: input.context,
+		tags: input.tags ?? [],
+		template: input.template ?? getDefaultAnkiFieldTemplates(),
+		duplicateScope: input.duplicateScope ?? "collection",
+		duplicateScopeCheckAllModels: input.duplicateScopeCheckAllModels ?? false,
+		resultOutputMode: input.resultOutputMode ?? "split",
+		glossaryLayoutMode: input.glossaryLayoutMode ?? "default",
+		compactTags: input.compactTags ?? false,
+		dictionaryStylesMap: input.dictionaryStylesMap ?? new Map()
+	});
+}
+
+//#endregion
+//#region src/anki/anki-template-util.ts
+/**
+* Gets the standard marker names available for a given entry type.
+*/
+function getStandardFieldMarkers(type, language = "ja") {
+	switch (type) {
+		case "term": {
+			const markers = [
+				"audio",
+				"clipboard-image",
+				"clipboard-text",
+				"cloze-body",
+				"cloze-prefix",
+				"cloze-suffix",
+				"conjugation",
+				"dictionary",
+				"dictionary-alias",
+				"document-title",
+				"expression",
+				"frequencies",
+				"frequency-harmonic-rank",
+				"frequency-harmonic-occurrence",
+				"frequency-average-rank",
+				"frequency-average-occurrence",
+				"furigana",
+				"furigana-plain",
+				"glossary",
+				"glossary-brief",
+				"glossary-no-dictionary",
+				"glossary-plain",
+				"glossary-plain-no-dictionary",
+				"glossary-first",
+				"glossary-first-brief",
+				"glossary-first-no-dictionary",
+				"part-of-speech",
+				"phonetic-transcriptions",
+				"reading",
+				"screenshot",
+				"search-query",
+				"popup-selection-text",
+				"sentence",
+				"sentence-furigana",
+				"sentence-furigana-plain",
+				"tags",
+				"url"
+			];
+			if (language === "ja") markers.push("cloze-body-kana", "pitch-accents", "pitch-accent-graphs", "pitch-accent-graphs-jj", "pitch-accent-positions", "pitch-accent-categories");
+			return markers;
+		}
+		case "kanji": return [
+			"character",
+			"clipboard-image",
+			"clipboard-text",
+			"cloze-body",
+			"cloze-prefix",
+			"cloze-suffix",
+			"dictionary",
+			"dictionary-alias",
+			"document-title",
+			"frequencies",
+			"frequency-harmonic-rank",
+			"frequency-harmonic-occurrence",
+			"frequency-average-rank",
+			"frequency-average-occurrence",
+			"glossary",
+			"kunyomi",
+			"onyomi",
+			"onyomi-hiragana",
+			"screenshot",
+			"search-query",
+			"popup-selection-text",
+			"sentence",
+			"sentence-furigana",
+			"sentence-furigana-plain",
+			"stroke-count",
+			"tags",
+			"url"
+		];
+		default: return [];
+	}
+}
+/**
+* Returns dynamic marker names derived from enabled dictionaries.
+*/
+function getDynamicFieldMarkers(dictionaries, dictionaryInfo) {
+	const markers = [];
+	for (const dictionary of dictionaries) {
+		const currentDictionaryInfo = dictionaryInfo.find(({ title }) => title === dictionary.name);
+		if (!dictionary.enabled) continue;
+		const totalTerms = currentDictionaryInfo?.counts?.terms?.total;
+		if (totalTerms && totalTerms > 0) markers.push(`single-glossary-${getKebabCase(dictionary.name)}`);
+		const totalMeta = currentDictionaryInfo?.counts?.termMeta;
+		if (totalMeta && totalMeta.freq && totalMeta.freq > 0) markers.push(`single-frequency-number-${getKebabCase(dictionary.name)}`);
+	}
+	return markers;
+}
+/**
+* Returns dynamic inline template partials derived from enabled dictionaries.
+*/
+function getDynamicTemplates(dictionaries, dictionaryInfo) {
+	let dynamicTemplates = "\n";
+	for (const dictionary of dictionaries) {
+		const currentDictionaryInfo = dictionaryInfo.find(({ title }) => title === dictionary.name);
+		if (!dictionary.enabled) continue;
+		const totalTerms = currentDictionaryInfo?.counts?.terms?.total;
+		if (totalTerms && totalTerms > 0) dynamicTemplates += `
+{{#*inline "single-glossary-${getKebabCase(dictionary.name)}"}}
+    {{~> glossary selectedDictionary='${escapeDictName(dictionary.name)}'}}
+{{/inline}}
+
+{{#*inline "single-glossary-${getKebabCase(dictionary.name)}-no-dictionary"}}
+    {{~> glossary selectedDictionary='${escapeDictName(dictionary.name)}' noDictionaryTag=true}}
+{{/inline}}
+
+{{#*inline "single-glossary-${getKebabCase(dictionary.name)}-brief"}}
+    {{~> glossary selectedDictionary='${escapeDictName(dictionary.name)}' brief=true}}
+{{/inline}}
+
+{{#*inline "single-glossary-${getKebabCase(dictionary.name)}-plain"}}
+    {{~> glossary-plain selectedDictionary='${escapeDictName(dictionary.name)}'}}
+{{/inline}}
+
+{{#*inline "single-glossary-${getKebabCase(dictionary.name)}-plain-no-dictionary"}}
+    {{~> glossary-plain-no-dictionary selectedDictionary='${escapeDictName(dictionary.name)}' noDictionaryTag=true}}
+{{/inline}}
+`;
+		const totalMeta = currentDictionaryInfo?.counts?.termMeta;
+		if (totalMeta && totalMeta.freq && totalMeta.freq > 0) dynamicTemplates += `
+{{#*inline "single-frequency-number-${getKebabCase(dictionary.name)}"}}
+    {{~> single-frequency-number selectedDictionary='${escapeDictName(dictionary.name)}'}}
+{{/inline}}
+{{#*inline "single-frequency-${getKebabCase(dictionary.name)}"}}
+    {{~> frequencies selectedDictionary='${escapeDictName(dictionary.name)}'}}
+{{/inline}}
+`;
+	}
+	return dynamicTemplates;
+}
+function getKebabCase(str) {
+	return str.replace(/[\s_\u3000]/g, "-").replace(/[^\p{L}\p{N}-]/gu, "").replace(/--+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+}
+function escapeDictName(name) {
+	return name.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+
 //#endregion
 exports.AnkiConnect = require_anki_connect.AnkiConnect
 exports.AnkiNoteBuilder = AnkiNoteBuilder
 exports.AnkiTemplateRenderer = AnkiTemplateRenderer
+exports.DEFAULT_ANKI_FIELD_TEMPLATES = DEFAULT_ANKI_FIELD_TEMPLATES
+exports.buildAnkiNoteFromDictionaryEntry = buildAnkiNoteFromDictionaryEntry
 exports.createAnkiNoteData = createAnkiNoteData
 exports.createCachedValue = createCachedValue
+exports.createDefaultAnkiTemplateRenderer = createDefaultAnkiTemplateRenderer
 exports.getCachedValue = getCachedValue
+exports.getDefaultAnkiFieldTemplates = getDefaultAnkiFieldTemplates
+exports.getDynamicFieldMarkers = getDynamicFieldMarkers
+exports.getDynamicTemplates = getDynamicTemplates
 exports.getFrequencyHarmonic = getFrequencyHarmonic
+exports.getKebabCase = getKebabCase
+exports.getStandardFieldMarkers = getStandardFieldMarkers
 //# sourceMappingURL=anki.cjs.map