yomitan-core 0.1.0

package/dist/anki.js

@@ -0,0 +1,1751 @@
+import { deferPromise } from "./utilities-bi3EF-q5.js";
+import "./cjk-util-DubXBGDG.js";
+import { YomitanError } from "./errors-DuuDSO5N.js";
+import { getDisambiguations, getGroupedPronunciations, getPronunciationsOfType, getTermFrequency, groupTermTags, isNonNounVerbOrAdjective } from "./dictionary-data-util-CfOLfEDE.js";
+import "./json-DGd-cunA.js";
+import { distributeFurigana } from "./furigana-B3-0y231.js";
+import { AnkiConnect, cloneFieldMarkerPattern, getRootDeckName } from "./anki-connect-DbrQHphS.js";
+
+//#region src/anki/anki-note-builder.ts
+/**
+* Builds Anki notes from dictionary entries using template rendering.
+*/
+var AnkiNoteBuilder = class {
+	_api;
+	_markerPattern;
+	_templateRenderer;
+	_batchedRequests;
+	_batchedRequestsQueued;
+	constructor(templateRenderer, api) {
+		this._api = api ?? null;
+		this._markerPattern = cloneFieldMarkerPattern(true);
+		this._templateRenderer = templateRenderer;
+		this._batchedRequests = [];
+		this._batchedRequestsQueued = false;
+	}
+	async createNote({ dictionaryEntry, cardFormat, context, template, tags = [], requirements = [], duplicateScope = "collection", duplicateScopeCheckAllModels = false, resultOutputMode = "split", glossaryLayoutMode = "default", compactTags = false, mediaOptions = null, dictionaryStylesMap = new Map() }) {
+		const { deck: deckName, model: modelName, fields: fieldsSettings } = cardFormat;
+		const fields = Object.entries(fieldsSettings);
+		let duplicateScopeDeckName = null;
+		let duplicateScopeCheckChildren = false;
+		if (duplicateScope === "deck-root") {
+			duplicateScope = "deck";
+			duplicateScopeDeckName = getRootDeckName(deckName);
+			duplicateScopeCheckChildren = true;
+		}
+		const allErrors = [];
+		let media;
+		if (requirements.length > 0 && mediaOptions !== null && this._api !== null) {
+			let errors;
+			({media, errors} = await this._injectMedia(dictionaryEntry, requirements, mediaOptions));
+			for (const error of errors) allErrors.push(this._deserializeError(error));
+		}
+		const commonData = this._createData(dictionaryEntry, cardFormat, context, resultOutputMode, glossaryLayoutMode, compactTags, media, dictionaryStylesMap);
+		const formattedFieldValuePromises = [];
+		for (const [, { value: fieldValue }] of fields) {
+			const formattedFieldValuePromise = this._formatField(fieldValue, commonData, template);
+			formattedFieldValuePromises.push(formattedFieldValuePromise);
+		}
+		const formattedFieldValues = await Promise.all(formattedFieldValuePromises);
+		const uniqueRequirements = new Map();
+		const noteFields = {};
+		for (let i = 0, ii = fields.length; i < ii; ++i) {
+			const fieldName = fields[i][0];
+			const { value, errors: fieldErrors, requirements: fieldRequirements } = formattedFieldValues[i];
+			noteFields[fieldName] = value;
+			allErrors.push(...fieldErrors);
+			for (const requirement of fieldRequirements) {
+				const key = JSON.stringify(requirement);
+				if (uniqueRequirements.has(key)) continue;
+				uniqueRequirements.set(key, requirement);
+			}
+		}
+		const note = {
+			fields: noteFields,
+			tags,
+			deckName,
+			modelName,
+			options: {
+				allowDuplicate: true,
+				duplicateScope,
+				duplicateScopeOptions: {
+					deckName: duplicateScopeDeckName,
+					checkChildren: duplicateScopeCheckChildren,
+					checkAllModels: duplicateScopeCheckAllModels
+				}
+			}
+		};
+		return {
+			note,
+			errors: allErrors,
+			requirements: [...uniqueRequirements.values()]
+		};
+	}
+	async getRenderingData({ dictionaryEntry, cardFormat, context, resultOutputMode = "split", glossaryLayoutMode = "default", compactTags = false, marker, dictionaryStylesMap }) {
+		const commonData = this._createData(dictionaryEntry, cardFormat, context, resultOutputMode, glossaryLayoutMode, compactTags, void 0, dictionaryStylesMap);
+		return await this._templateRenderer.getModifiedData({
+			marker,
+			commonData
+		}, "ankiNote");
+	}
+	getDictionaryEntryDetailsForNote(dictionaryEntry) {
+		const { type } = dictionaryEntry;
+		if (type === "kanji") {
+			const { character } = dictionaryEntry;
+			return {
+				type,
+				character
+			};
+		}
+		const { headwords } = dictionaryEntry;
+		let bestIndex = -1;
+		for (let i = 0, ii = headwords.length; i < ii; ++i) {
+			const { term: term$1, reading: reading$1, sources } = headwords[i];
+			for (const { deinflectedText } of sources) {
+				if (term$1 === deinflectedText) {
+					bestIndex = i;
+					i = ii;
+					break;
+				}
+				if (reading$1 === deinflectedText && bestIndex < 0) {
+					bestIndex = i;
+					break;
+				}
+			}
+		}
+		const { term, reading } = headwords[Math.max(0, bestIndex)];
+		return {
+			type,
+			term,
+			reading
+		};
+	}
+	_createData(dictionaryEntry, cardFormat, context, resultOutputMode, glossaryLayoutMode, compactTags, media, dictionaryStylesMap) {
+		return {
+			dictionaryEntry,
+			cardFormat,
+			context,
+			resultOutputMode,
+			glossaryLayoutMode,
+			compactTags,
+			media,
+			dictionaryStylesMap
+		};
+	}
+	async _formatField(field, commonData, template) {
+		const errors = [];
+		const requirements = [];
+		const value = await this._stringReplaceAsync(field, this._markerPattern, async (match) => {
+			const marker = match[1];
+			try {
+				const { result, requirements: fieldRequirements } = await this._renderTemplateBatched(template, commonData, marker);
+				requirements.push(...fieldRequirements);
+				return result;
+			} catch (e) {
+				const error = new YomitanError(`Template render error for {${marker}}`);
+				error.data = { error: e };
+				errors.push(error);
+				return `{${marker}-render-error}`;
+			}
+		});
+		return {
+			value,
+			errors,
+			requirements
+		};
+	}
+	async _stringReplaceAsync(str, regex, replacer) {
+		let match;
+		let index = 0;
+		const parts = [];
+		while ((match = regex.exec(str)) !== null) {
+			parts.push(str.substring(index, match.index), replacer(match, match.index, str));
+			index = regex.lastIndex;
+		}
+		if (parts.length === 0) return str;
+		parts.push(str.substring(index));
+		return (await Promise.all(parts)).join("");
+	}
+	_getBatchedTemplateGroup(template) {
+		for (const item of this._batchedRequests) if (item.template === template) return item;
+		const result = {
+			template,
+			commonDataRequestsMap: new Map()
+		};
+		this._batchedRequests.push(result);
+		return result;
+	}
+	_renderTemplateBatched(template, commonData, marker) {
+		const { promise, resolve, reject } = deferPromise();
+		const { commonDataRequestsMap } = this._getBatchedTemplateGroup(template);
+		let requests = commonDataRequestsMap.get(commonData);
+		if (typeof requests === "undefined") {
+			requests = [];
+			commonDataRequestsMap.set(commonData, requests);
+		}
+		requests.push({
+			resolve,
+			reject,
+			marker
+		});
+		this._runBatchedRequestsDelayed();
+		return promise;
+	}
+	_runBatchedRequestsDelayed() {
+		if (this._batchedRequestsQueued) return;
+		this._batchedRequestsQueued = true;
+		Promise.resolve().then(() => {
+			this._batchedRequestsQueued = false;
+			this._runBatchedRequests();
+		});
+	}
+	_runBatchedRequests() {
+		if (this._batchedRequests.length === 0) return;
+		const allRequests = [];
+		const items = [];
+		for (const { template, commonDataRequestsMap } of this._batchedRequests) {
+			const templateItems = [];
+			for (const [commonData, requests] of commonDataRequestsMap.entries()) {
+				const datas = [];
+				for (const { marker } of requests) datas.push({ marker });
+				allRequests.push(...requests);
+				templateItems.push({
+					type: "ankiNote",
+					commonData,
+					datas
+				});
+			}
+			items.push({
+				template,
+				templateItems
+			});
+		}
+		this._batchedRequests.length = 0;
+		this._resolveBatchedRequests(items, allRequests);
+	}
+	async _resolveBatchedRequests(items, requests) {
+		let responses;
+		try {
+			responses = await this._templateRenderer.renderMulti(items);
+		} catch (e) {
+			for (const { reject } of requests) reject(e);
+			return;
+		}
+		for (let i = 0, ii = requests.length; i < ii; ++i) {
+			const request = requests[i];
+			try {
+				const response = responses[i];
+				const { error } = response;
+				if (typeof error !== "undefined") throw this._deserializeError(error);
+				request.resolve(response.result);
+			} catch (e) {
+				request.reject(e);
+			}
+		}
+	}
+	async _injectMedia(dictionaryEntry, requirements, mediaOptions) {
+		const timestamp = Date.now();
+		let injectAudio = false;
+		let injectScreenshot = false;
+		let injectClipboardImage = false;
+		let injectClipboardText = false;
+		let injectPopupSelectionText = false;
+		const dictionaryMediaDetails = [];
+		for (const requirement of requirements) {
+			const { type } = requirement;
+			switch (type) {
+				case "audio":
+					injectAudio = true;
+					break;
+				case "screenshot":
+					injectScreenshot = true;
+					break;
+				case "clipboardImage":
+					injectClipboardImage = true;
+					break;
+				case "clipboardText":
+					injectClipboardText = true;
+					break;
+				case "popupSelectionText":
+					injectPopupSelectionText = true;
+					break;
+				case "dictionaryMedia":
+					{
+						const { dictionary, path } = requirement;
+						dictionaryMediaDetails.push({
+							dictionary,
+							path
+						});
+					}
+					break;
+			}
+		}
+		const dictionaryEntryDetails = this.getDictionaryEntryDetailsForNote(dictionaryEntry);
+		let audioDetails = null;
+		let screenshotDetails = null;
+		const clipboardDetails = {
+			image: injectClipboardImage,
+			text: injectClipboardText
+		};
+		if (injectAudio && dictionaryEntryDetails.type !== "kanji") {
+			const audioOptions = mediaOptions.audio;
+			if (typeof audioOptions === "object" && audioOptions !== null) {
+				const { sources, preferredAudioIndex, idleTimeout, languageSummary, enableDefaultAudioSources } = audioOptions;
+				audioDetails = {
+					sources,
+					preferredAudioIndex,
+					idleTimeout,
+					languageSummary,
+					enableDefaultAudioSources
+				};
+			}
+		}
+		if (injectScreenshot) {
+			const screenshotOptions = mediaOptions.screenshot;
+			if (typeof screenshotOptions === "object" && screenshotOptions !== null) {
+				const { format, quality, contentOrigin: { tabId, frameId } } = screenshotOptions;
+				if (typeof tabId === "number" && typeof frameId === "number") screenshotDetails = {
+					tabId,
+					frameId,
+					format,
+					quality
+				};
+			}
+		}
+		const injectedMedia = await this._api?.injectAnkiNoteMedia(timestamp, dictionaryEntryDetails, audioDetails, screenshotDetails, clipboardDetails, dictionaryMediaDetails);
+		if (!injectedMedia) throw new Error("Media injection API is not available");
+		const { audioFileName, screenshotFileName, clipboardImageFileName, clipboardText, dictionaryMedia: dictionaryMediaArray, errors } = injectedMedia;
+		const dictionaryMedia = {};
+		for (const { dictionary, path, fileName } of dictionaryMediaArray) {
+			if (fileName === null) continue;
+			const dictionaryMedia2 = Object.prototype.hasOwnProperty.call(dictionaryMedia, dictionary) ? dictionaryMedia[dictionary] : dictionaryMedia[dictionary] = {};
+			dictionaryMedia2[path] = { value: fileName };
+		}
+		const media = {
+			audio: typeof audioFileName === "string" ? { value: audioFileName } : void 0,
+			screenshot: typeof screenshotFileName === "string" ? { value: screenshotFileName } : void 0,
+			clipboardImage: typeof clipboardImageFileName === "string" ? { value: clipboardImageFileName } : void 0,
+			clipboardText: typeof clipboardText === "string" ? { value: clipboardText } : void 0,
+			popupSelectionText: injectPopupSelectionText ? { value: "" } : void 0,
+			textFurigana: [],
+			dictionaryMedia
+		};
+		return {
+			media,
+			errors
+		};
+	}
+	_deserializeError(error) {
+		const e = new YomitanError(error.message ?? "Unknown error");
+		e.data = error.data;
+		return e;
+	}
+};
+
+//#endregion
+//#region src/anki/anki-note-data-creator.ts
+function createCachedValue(getter) {
+	return {
+		getter,
+		hasValue: false,
+		value: void 0
+	};
+}
+function getCachedValue(item) {
+	if (item.hasValue) return item.value;
+	const value = item.getter();
+	item.value = value;
+	item.hasValue = true;
+	return value;
+}
+/**
+* Creates a compatibility representation of the specified data for Anki template rendering.
+*/
+function createAnkiNoteData(marker, details) {
+	const { dictionaryEntry, resultOutputMode, glossaryLayoutMode, compactTags, context, media, dictionaryStylesMap } = details;
+	const definition = createCachedValue(() => getDefinition(dictionaryEntry, context, resultOutputMode, dictionaryStylesMap, glossaryLayoutMode));
+	const uniqueExpressions = createCachedValue(() => getUniqueExpressions(dictionaryEntry));
+	const uniqueReadings = createCachedValue(() => getUniqueReadings(dictionaryEntry));
+	const context2 = createCachedValue(() => getPublicContext(context));
+	const pitches = createCachedValue(() => getPitches(dictionaryEntry));
+	const pitchCount = createCachedValue(() => getPitchCount(pitches));
+	const phoneticTranscriptions = createCachedValue(() => getPhoneticTranscriptions(dictionaryEntry));
+	let resolvedMedia;
+	if (typeof media !== "object" || media === null || Array.isArray(media)) resolvedMedia = {
+		audio: void 0,
+		screenshot: void 0,
+		clipboardImage: void 0,
+		clipboardText: void 0,
+		popupSelectionText: void 0,
+		textFurigana: [],
+		dictionaryMedia: {}
+	};
+	else resolvedMedia = media;
+	const result = {
+		marker,
+		get definition() {
+			return getCachedValue(definition);
+		},
+		glossaryLayoutMode,
+		compactTags,
+		group: resultOutputMode === "group",
+		merge: resultOutputMode === "merge",
+		compactGlossaries: glossaryLayoutMode === "compact-popup-anki",
+		get uniqueExpressions() {
+			return getCachedValue(uniqueExpressions);
+		},
+		get uniqueReadings() {
+			return getCachedValue(uniqueReadings);
+		},
+		get pitches() {
+			return getCachedValue(pitches);
+		},
+		get pitchCount() {
+			return getCachedValue(pitchCount);
+		},
+		get phoneticTranscriptions() {
+			return getCachedValue(phoneticTranscriptions);
+		},
+		get context() {
+			return getCachedValue(context2);
+		},
+		media: resolvedMedia,
+		dictionaryEntry
+	};
+	Object.defineProperty(result, "dictionaryEntry", {
+		configurable: false,
+		enumerable: false,
+		writable: false,
+		value: dictionaryEntry
+	});
+	return result;
+}
+function getPrimarySource(dictionaryEntry) {
+	for (const headword of dictionaryEntry.headwords) for (const source of headword.sources) if (source.isPrimary) return source;
+	return null;
+}
+function getUniqueExpressions(dictionaryEntry) {
+	if (dictionaryEntry.type === "term") {
+		const results = new Set();
+		for (const { term } of dictionaryEntry.headwords) results.add(term);
+		return [...results];
+	}
+	return [];
+}
+function getUniqueReadings(dictionaryEntry) {
+	if (dictionaryEntry.type === "term") {
+		const results = new Set();
+		for (const { reading } of dictionaryEntry.headwords) results.add(reading);
+		return [...results];
+	}
+	return [];
+}
+function getPublicContext(context) {
+	let { documentTitle } = context;
+	if (typeof documentTitle !== "string") documentTitle = "";
+	return {
+		query: context.query,
+		fullQuery: context.fullQuery,
+		document: { title: documentTitle }
+	};
+}
+function getFrequencyNumbers(dictionaryEntry, requestedHeadwordIndex) {
+	let previousDictionary;
+	const frequencies = [];
+	for (const dictionaryEntryFrequency of dictionaryEntry.frequencies) {
+		const { dictionary, frequency, displayValue } = dictionaryEntryFrequency;
+		const wrongHeadwordIndex = Number.isInteger(requestedHeadwordIndex) && "headwordIndex" in dictionaryEntryFrequency && dictionaryEntryFrequency.headwordIndex !== requestedHeadwordIndex;
+		if (dictionary === previousDictionary || wrongHeadwordIndex) continue;
+		previousDictionary = dictionary;
+		if (displayValue !== null) {
+			const frequencyMatch = displayValue.match(/^\d+/);
+			if (frequencyMatch !== null) {
+				const frequencyParsed = Number.parseInt(frequencyMatch[0], 10);
+				if (frequencyParsed > 0) {
+					frequencies.push({
+						dictionary,
+						frequency: frequencyParsed
+					});
+					continue;
+				}
+			}
+		}
+		if (frequency > 0) frequencies.push({
+			dictionary,
+			frequency
+		});
+	}
+	return frequencies;
+}
+function getFrequencyHarmonic(dictionaryEntry, headwordIndex) {
+	const frequencies = getFrequencyNumbers(dictionaryEntry, headwordIndex);
+	if (frequencies.length === 0) return -1;
+	let total = 0;
+	for (const frequency of frequencies) total += 1 / frequency.frequency;
+	return Math.floor(frequencies.length / total);
+}
+function getFrequencyAverage(dictionaryEntry, headwordIndex) {
+	const frequencies = getFrequencyNumbers(dictionaryEntry, headwordIndex);
+	if (frequencies.length === 0) return -1;
+	let total = 0;
+	for (const frequency of frequencies) total += frequency.frequency;
+	return Math.floor(total / frequencies.length);
+}
+function getPitches(dictionaryEntry) {
+	const results = [];
+	if (dictionaryEntry.type === "term") for (const { dictionary, pronunciations } of getGroupedPronunciations(dictionaryEntry)) {
+		const pitches = [];
+		for (const groupedPronunciation of pronunciations) {
+			const { pronunciation } = groupedPronunciation;
+			if (pronunciation.type !== "pitch-accent") continue;
+			const { positions, nasalPositions, devoicePositions, tags } = pronunciation;
+			const { terms, reading, exclusiveTerms, exclusiveReadings } = groupedPronunciation;
+			pitches.push({
+				expressions: terms,
+				reading,
+				positions,
+				nasalPositions,
+				devoicePositions,
+				tags: convertPitchTags(tags),
+				exclusiveExpressions: exclusiveTerms,
+				exclusiveReadings
+			});
+		}
+		results.push({
+			dictionary,
+			pitches
+		});
+	}
+	return results;
+}
+function getPhoneticTranscriptions(dictionaryEntry) {
+	const results = [];
+	if (dictionaryEntry.type === "term") for (const { dictionary, pronunciations } of getGroupedPronunciations(dictionaryEntry)) {
+		const phoneticTranscriptions = [];
+		for (const groupedPronunciation of pronunciations) {
+			const { pronunciation } = groupedPronunciation;
+			if (pronunciation.type !== "phonetic-transcription") continue;
+			const { ipa, tags } = pronunciation;
+			const { terms, reading, exclusiveTerms, exclusiveReadings } = groupedPronunciation;
+			phoneticTranscriptions.push({
+				expressions: terms,
+				reading,
+				ipa,
+				tags,
+				exclusiveExpressions: exclusiveTerms,
+				exclusiveReadings
+			});
+		}
+		results.push({
+			dictionary,
+			phoneticTranscriptions
+		});
+	}
+	return results;
+}
+function getPitchCount(cachedPitches) {
+	const pitches = getCachedValue(cachedPitches);
+	return pitches.reduce((i, v) => i + v.pitches.length, 0);
+}
+function getDefinition(dictionaryEntry, context, resultOutputMode, dictionaryStylesMap, glossaryLayoutMode) {
+	switch (dictionaryEntry.type) {
+		case "term": return getTermDefinition(dictionaryEntry, context, resultOutputMode, dictionaryStylesMap, glossaryLayoutMode);
+		case "kanji": return getKanjiDefinition(dictionaryEntry, context);
+		default: return {};
+	}
+}
+function getKanjiDefinition(dictionaryEntry, context) {
+	const { character, dictionary, dictionaryAlias, onyomi, kunyomi, definitions } = dictionaryEntry;
+	let { url } = context;
+	if (typeof url !== "string") url = "";
+	const stats = createCachedValue(() => getKanjiStats(dictionaryEntry));
+	const tags = createCachedValue(() => convertTags(dictionaryEntry.tags));
+	const frequencies = createCachedValue(() => getKanjiFrequencies(dictionaryEntry));
+	const frequencyHarmonic = createCachedValue(() => getFrequencyHarmonic(dictionaryEntry, null));
+	const frequencyAverage = createCachedValue(() => getFrequencyAverage(dictionaryEntry, null));
+	const cloze = createCachedValue(() => getCloze(dictionaryEntry, context));
+	return {
+		type: "kanji",
+		character,
+		dictionary,
+		dictionaryAlias,
+		onyomi,
+		kunyomi,
+		glossary: definitions,
+		get tags() {
+			return getCachedValue(tags);
+		},
+		get stats() {
+			return getCachedValue(stats);
+		},
+		get frequencies() {
+			return getCachedValue(frequencies);
+		},
+		get frequencyHarmonic() {
+			return getCachedValue(frequencyHarmonic);
+		},
+		get frequencyAverage() {
+			return getCachedValue(frequencyAverage);
+		},
+		url,
+		get cloze() {
+			return getCachedValue(cloze);
+		}
+	};
+}
+function getKanjiStats(dictionaryEntry) {
+	const results = {};
+	for (const [key, value] of Object.entries(dictionaryEntry.stats)) results[key] = value.map(convertKanjiStat);
+	return results;
+}
+function convertKanjiStat({ name, category, content, order, score, dictionary, value }) {
+	return {
+		name,
+		category,
+		notes: content,
+		order,
+		score,
+		dictionary,
+		value
+	};
+}
+function getKanjiFrequencies(dictionaryEntry) {
+	const results = [];
+	for (const { index, dictionary, dictionaryAlias, dictionaryIndex, character, frequency, displayValue } of dictionaryEntry.frequencies) results.push({
+		index,
+		dictionary,
+		dictionaryAlias,
+		dictionaryOrder: { index: dictionaryIndex },
+		character,
+		frequency: displayValue !== null ? displayValue : frequency
+	});
+	return results;
+}
+function getTermDefinition(dictionaryEntry, context, resultOutputMode, dictionaryStylesMap, glossaryLayoutMode) {
+	let type = "term";
+	switch (resultOutputMode) {
+		case "group":
+			type = "termGrouped";
+			break;
+		case "merge":
+			type = "termMerged";
+			break;
+	}
+	const { inflectionRuleChainCandidates, score, dictionaryIndex, sourceTermExactMatchCount, definitions } = dictionaryEntry;
+	let { url } = context;
+	if (typeof url !== "string") url = "";
+	const primarySource = getPrimarySource(dictionaryEntry);
+	const dictionaryAliases = createCachedValue(() => getTermDictionaryAliases(dictionaryEntry));
+	const dictionaryNames = createCachedValue(() => getTermDictionaryNames(dictionaryEntry));
+	const commonInfo = createCachedValue(() => getTermDictionaryEntryCommonInfo(dictionaryEntry, type, dictionaryStylesMap, glossaryLayoutMode));
+	const termTags = createCachedValue(() => getTermTags(dictionaryEntry, type));
+	const expressions = createCachedValue(() => getTermExpressions(dictionaryEntry));
+	const frequencies = createCachedValue(() => getTermFrequenciesAnki(dictionaryEntry));
+	const frequencyNumbersCV = createCachedValue(() => getFrequencyNumbers(dictionaryEntry, null));
+	const frequencyHarmonic = createCachedValue(() => getFrequencyHarmonic(dictionaryEntry, null));
+	const frequencyAverage = createCachedValue(() => getFrequencyAverage(dictionaryEntry, null));
+	const pitches = createCachedValue(() => getTermPitches(dictionaryEntry));
+	const phoneticTranscriptions = createCachedValue(() => getTermPhoneticTranscriptions(dictionaryEntry));
+	const glossary = createCachedValue(() => getTermGlossaryArray(dictionaryEntry, type));
+	const styleInfo = createCachedValue(() => getTermStyles(dictionaryEntry, type, dictionaryStylesMap));
+	const cloze = createCachedValue(() => getCloze(dictionaryEntry, context));
+	const furiganaSegments = createCachedValue(() => getTermFuriganaSegments(dictionaryEntry, type));
+	const sequence = createCachedValue(() => getTermDictionaryEntrySequence(dictionaryEntry));
+	return {
+		type,
+		id: type === "term" && definitions.length > 0 ? definitions[0].id : void 0,
+		source: primarySource !== null ? primarySource.transformedText : null,
+		rawSource: primarySource !== null ? primarySource.originalText : null,
+		sourceTerm: type !== "termMerged" ? primarySource !== null ? primarySource.deinflectedText : null : void 0,
+		inflectionRuleChainCandidates,
+		score,
+		isPrimary: type === "term" ? dictionaryEntry.isPrimary : void 0,
+		get sequence() {
+			return getCachedValue(sequence);
+		},
+		get dictionary() {
+			return getCachedValue(dictionaryNames)[0];
+		},
+		get dictionaryAlias() {
+			return getCachedValue(dictionaryAliases)[0];
+		},
+		dictionaryOrder: { index: dictionaryIndex },
+		get dictionaryNames() {
+			return getCachedValue(dictionaryNames);
+		},
+		get expression() {
+			const { uniqueTerms } = getCachedValue(commonInfo);
+			return type === "term" || type === "termGrouped" ? uniqueTerms[0] : uniqueTerms;
+		},
+		get reading() {
+			const { uniqueReadings } = getCachedValue(commonInfo);
+			return type === "term" || type === "termGrouped" ? uniqueReadings[0] : uniqueReadings;
+		},
+		get expressions() {
+			return getCachedValue(expressions);
+		},
+		get glossary() {
+			return getCachedValue(glossary);
+		},
+		get glossaryScopedStyles() {
+			return getCachedValue(styleInfo)?.glossaryScopedStyles;
+		},
+		get dictScopedStyles() {
+			return getCachedValue(styleInfo)?.dictScopedStyles;
+		},
+		get definitionTags() {
+			return type === "term" ? getCachedValue(commonInfo).definitionTags : void 0;
+		},
+		get termTags() {
+			return getCachedValue(termTags);
+		},
+		get definitions() {
+			return getCachedValue(commonInfo).definitions;
+		},
+		get frequencies() {
+			return getCachedValue(frequencies);
+		},
+		get frequencyNumbers() {
+			return getCachedValue(frequencyNumbersCV);
+		},
+		get frequencyHarmonic() {
+			return getCachedValue(frequencyHarmonic);
+		},
+		get frequencyAverage() {
+			return getCachedValue(frequencyAverage);
+		},
+		get pitches() {
+			return getCachedValue(pitches);
+		},
+		get phoneticTranscriptions() {
+			return getCachedValue(phoneticTranscriptions);
+		},
+		sourceTermExactMatchCount,
+		url,
+		get cloze() {
+			return getCachedValue(cloze);
+		},
+		get furiganaSegments() {
+			return getCachedValue(furiganaSegments);
+		}
+	};
+}
+function getTermDictionaryNames(dictionaryEntry) {
+	const dictionaryNames = new Set();
+	for (const { dictionary } of dictionaryEntry.definitions) dictionaryNames.add(dictionary);
+	return [...dictionaryNames];
+}
+function getTermDictionaryAliases(dictionaryEntry) {
+	const dictionaryAliases = new Set();
+	for (const { dictionaryAlias } of dictionaryEntry.definitions) dictionaryAliases.add(dictionaryAlias);
+	return [...dictionaryAliases];
+}
+function getTermDictionaryEntryCommonInfo(dictionaryEntry, type, _dictionaryStylesMap, _glossaryLayoutMode) {
+	const merged = type === "termMerged";
+	const hasDefinitions = type !== "term";
+	const allTermsSet = new Set();
+	const allReadingsSet = new Set();
+	for (const { term, reading } of dictionaryEntry.headwords) {
+		allTermsSet.add(term);
+		allReadingsSet.add(reading);
+	}
+	const uniqueTerms = [...allTermsSet];
+	const uniqueReadings = [...allReadingsSet];
+	const definitions = [];
+	const definitionTags = [];
+	for (const { tags, headwordIndices, entries, dictionary, dictionaryAlias, sequences } of dictionaryEntry.definitions) {
+		const definitionTags2 = [];
+		for (const tag of tags) {
+			definitionTags.push(convertTag(tag));
+			definitionTags2.push(convertTag(tag));
+		}
+		if (!hasDefinitions) continue;
+		const only = merged ? getDisambiguations(dictionaryEntry.headwords, headwordIndices, allTermsSet, allReadingsSet) : void 0;
+		definitions.push({
+			sequence: sequences[0],
+			dictionary,
+			dictionaryAlias,
+			glossaryScopedStyles: "",
+			dictScopedStyles: "",
+			glossary: entries,
+			definitionTags: definitionTags2,
+			only
+		});
+	}
+	return {
+		uniqueTerms,
+		uniqueReadings,
+		definitionTags,
+		definitions: hasDefinitions ? definitions : void 0
+	};
+}
+function getTermFrequenciesAnki(dictionaryEntry) {
+	const results = [];
+	const { headwords } = dictionaryEntry;
+	for (const { headwordIndex, dictionary, dictionaryAlias, dictionaryIndex, hasReading, frequency, displayValue } of dictionaryEntry.frequencies) {
+		const { term, reading } = headwords[headwordIndex];
+		results.push({
+			index: results.length,
+			expressionIndex: headwordIndex,
+			dictionary,
+			dictionaryAlias,
+			dictionaryOrder: { index: dictionaryIndex },
+			expression: term,
+			reading,
+			hasReading,
+			frequency: displayValue !== null ? displayValue : frequency
+		});
+	}
+	return results;
+}
+function getTermPitches(dictionaryEntry) {
+	const results = [];
+	const { headwords } = dictionaryEntry;
+	for (const { headwordIndex, dictionary, dictionaryAlias, dictionaryIndex, pronunciations } of dictionaryEntry.pronunciations) {
+		const { term, reading } = headwords[headwordIndex];
+		const pitchAccents = getPronunciationsOfType(pronunciations, "pitch-accent");
+		const cachedPitches = createCachedValue(() => getTermPitchesInner(pitchAccents));
+		results.push({
+			index: results.length,
+			expressionIndex: headwordIndex,
+			dictionary,
+			dictionaryAlias,
+			dictionaryOrder: { index: dictionaryIndex },
+			expression: term,
+			reading,
+			get pitches() {
+				return getCachedValue(cachedPitches);
+			}
+		});
+	}
+	return results;
+}
+function getTermPitchesInner(pitches) {
+	const results = [];
+	for (const { positions, tags } of pitches) {
+		const cachedTags = createCachedValue(() => convertTags(tags));
+		results.push({
+			positions,
+			get tags() {
+				return getCachedValue(cachedTags);
+			}
+		});
+	}
+	return results;
+}
+function getTermPhoneticTranscriptions(dictionaryEntry) {
+	const results = [];
+	const { headwords } = dictionaryEntry;
+	for (const { headwordIndex, dictionary, dictionaryAlias, dictionaryIndex, pronunciations } of dictionaryEntry.pronunciations) {
+		const { term, reading } = headwords[headwordIndex];
+		const phoneticTranscriptions = getPronunciationsOfType(pronunciations, "phonetic-transcription");
+		const termPhoneticTranscriptions = getTermPhoneticTranscriptionsInner(phoneticTranscriptions);
+		results.push({
+			index: results.length,
+			expressionIndex: headwordIndex,
+			dictionary,
+			dictionaryAlias,
+			dictionaryOrder: { index: dictionaryIndex },
+			expression: term,
+			reading,
+			get phoneticTranscriptions() {
+				return termPhoneticTranscriptions;
+			}
+		});
+	}
+	return results;
+}
+function getTermPhoneticTranscriptionsInner(phoneticTranscriptions) {
+	const results = [];
+	for (const { ipa, tags } of phoneticTranscriptions) {
+		const cachedTags = createCachedValue(() => convertTags(tags));
+		results.push({
+			ipa,
+			get tags() {
+				return getCachedValue(cachedTags);
+			}
+		});
+	}
+	return results;
+}
+function getTermExpressions(dictionaryEntry) {
+	const results = [];
+	const { headwords } = dictionaryEntry;
+	for (let i = 0, ii = headwords.length; i < ii; ++i) {
+		const { term, reading, tags, sources: [{ deinflectedText }], wordClasses } = headwords[i];
+		const termTagsCV = createCachedValue(() => convertTags(tags));
+		const frequenciesCV = createCachedValue(() => getTermExpressionFrequencies(dictionaryEntry, i));
+		const pitchesCV = createCachedValue(() => getTermExpressionPitches(dictionaryEntry, i));
+		const termFrequencyCV = createCachedValue(() => getTermExpressionTermFrequency(termTagsCV));
+		const furiganaSegmentsCV = createCachedValue(() => getTermHeadwordFuriganaSegments(term, reading));
+		const item = {
+			sourceTerm: deinflectedText,
+			expression: term,
+			reading,
+			get termTags() {
+				return getCachedValue(termTagsCV);
+			},
+			get frequencies() {
+				return getCachedValue(frequenciesCV);
+			},
+			get pitches() {
+				return getCachedValue(pitchesCV);
+			},
+			get furiganaSegments() {
+				return getCachedValue(furiganaSegmentsCV);
+			},
+			get termFrequency() {
+				return getCachedValue(termFrequencyCV);
+			},
+			wordClasses
+		};
+		results.push(item);
+	}
+	return results;
+}
+function getTermExpressionFrequencies(dictionaryEntry, i) {
+	const results = [];
+	const { headwords, frequencies } = dictionaryEntry;
+	for (const { headwordIndex, dictionary, dictionaryAlias, dictionaryIndex, hasReading, frequency, displayValue } of frequencies) {
+		if (headwordIndex !== i) continue;
+		const { term, reading } = headwords[headwordIndex];
+		results.push({
+			index: results.length,
+			expressionIndex: headwordIndex,
+			dictionary,
+			dictionaryAlias,
+			dictionaryOrder: { index: dictionaryIndex },
+			expression: term,
+			reading,
+			hasReading,
+			frequency: displayValue !== null ? displayValue : frequency
+		});
+	}
+	return results;
+}
+function getTermExpressionPitches(dictionaryEntry, i) {
+	const results = [];
+	const { headwords, pronunciations: termPronunciations } = dictionaryEntry;
+	for (const { headwordIndex, dictionary, dictionaryAlias, dictionaryIndex, pronunciations } of termPronunciations) {
+		if (headwordIndex !== i) continue;
+		const { term, reading } = headwords[headwordIndex];
+		const pitchAccents = getPronunciationsOfType(pronunciations, "pitch-accent");
+		const cachedPitches = createCachedValue(() => getTermPitchesInner(pitchAccents));
+		results.push({
+			index: results.length,
+			expressionIndex: headwordIndex,
+			dictionary,
+			dictionaryAlias,
+			dictionaryOrder: { index: dictionaryIndex },
+			expression: term,
+			reading,
+			get pitches() {
+				return getCachedValue(cachedPitches);
+			}
+		});
+	}
+	return results;
+}
+function getTermExpressionTermFrequency(cachedTermTags) {
+	const termTags = getCachedValue(cachedTermTags);
+	return getTermFrequency(termTags);
+}
+function getTermGlossaryArray(dictionaryEntry, type) {
+	if (type === "term") {
+		const results = [];
+		for (const { entries } of dictionaryEntry.definitions) results.push(...entries);
+		return results;
+	}
+	return void 0;
+}
+function getTermStyles(dictionaryEntry, type, _dictionaryStylesMap) {
+	if (type !== "term") return void 0;
+	return {
+		glossaryScopedStyles: "",
+		dictScopedStyles: ""
+	};
+}
+function getTermTags(dictionaryEntry, type) {
+	if (type !== "termMerged") {
+		const results = [];
+		for (const { tag } of groupTermTags(dictionaryEntry)) results.push(convertTag(tag));
+		return results;
+	}
+	return void 0;
+}
+function convertTags(tags) {
+	const results = [];
+	for (const tag of tags) results.push(convertTag(tag));
+	return results;
+}
+function convertTag({ name, category, content, order, score, dictionaries, redundant }) {
+	return {
+		name,
+		category,
+		notes: content.length > 0 ? content[0] : "",
+		order,
+		score,
+		dictionary: dictionaries.length > 0 ? dictionaries[0] : "",
+		redundant
+	};
+}
+function convertPitchTags(tags) {
+	const results = [];
+	for (const tag of tags) results.push(convertPitchTag(tag));
+	return results;
+}
+function convertPitchTag({ name, category, content, order, score, dictionaries, redundant }) {
+	return {
+		name,
+		category,
+		order,
+		score,
+		content: [...content],
+		dictionaries: [...dictionaries],
+		redundant
+	};
+}
+function getCloze(dictionaryEntry, context) {
+	let originalText = "";
+	let term = "";
+	let reading = "";
+	switch (dictionaryEntry.type) {
+		case "term":
+			{
+				term = dictionaryEntry.headwords[0].term;
+				reading = dictionaryEntry.headwords[0].reading;
+				const primarySource = getPrimarySource(dictionaryEntry);
+				if (primarySource !== null) originalText = primarySource.originalText;
+			}
+			break;
+		case "kanji":
+			originalText = dictionaryEntry.character;
+			break;
+	}
+	const { sentence } = context;
+	let text;
+	let offset;
+	if (typeof sentence === "object" && sentence !== null) ({text, offset} = sentence);
+	if (typeof text !== "string") text = "";
+	if (typeof offset !== "number") offset = 0;
+	const textChars = [...text];
+	const textSegments = [];
+	for (const { text: text2, reading: reading2 } of distributeFurigana(term, textChars.slice(offset, offset + originalText.length).join(""))) textSegments.push(reading2.length > 0 ? reading2 : text2);
+	return {
+		sentence: textChars.join(""),
+		prefix: textChars.slice(0, offset).join(""),
+		body: textChars.slice(offset, offset + originalText.length).join(""),
+		bodyKana: textSegments.join(""),
+		suffix: textChars.slice(offset + originalText.length).join("")
+	};
+}
+function getTermFuriganaSegments(dictionaryEntry, type) {
+	if (type === "term") for (const { term, reading } of dictionaryEntry.headwords) return getTermHeadwordFuriganaSegments(term, reading);
+	return void 0;
+}
+function getTermHeadwordFuriganaSegments(term, reading) {
+	const result = [];
+	for (const { text, reading: reading2 } of distributeFurigana(term, reading)) result.push({
+		text,
+		furigana: reading2
+	});
+	return result;
+}
+function getTermDictionaryEntrySequence(dictionaryEntry) {
+	let hasSequence = false;
+	let mainSequence = -1;
+	if (!dictionaryEntry.isPrimary) return mainSequence;
+	for (const { sequences } of dictionaryEntry.definitions) {
+		const sequence = sequences[0];
+		if (!hasSequence) {
+			mainSequence = sequence;
+			hasSequence = true;
+			if (mainSequence === -1) break;
+		} else if (mainSequence !== sequence) {
+			mainSequence = -1;
+			break;
+		}
+	}
+	return mainSequence;
+}
+
+//#endregion
+//#region src/anki/anki-template-renderer.ts
+/**
+* Manages media access during template rendering.
+*/
+var TemplateRendererMediaProvider = class {
+	_requirements;
+	constructor() {
+		this._requirements = null;
+	}
+	get requirements() {
+		return this._requirements;
+	}
+	set requirements(value) {
+		this._requirements = value;
+	}
+	hasMedia(root, args, namedArgs) {
+		const { media } = root;
+		const data = this._getMediaData(media, args, namedArgs);
+		return data !== null;
+	}
+	getMedia(root, args, namedArgs, handlebars) {
+		const { media } = root;
+		const data = this._getMediaData(media, args, namedArgs);
+		if (data !== null) {
+			const result = this._getFormattedValue(data, namedArgs, handlebars);
+			if (typeof result === "string") return result.replaceAll("\n", "<br>\n");
+		}
+		const defaultValue = namedArgs.default;
+		return defaultValue === null || typeof defaultValue === "string" ? defaultValue : "";
+	}
+	_addRequirement(value) {
+		if (this._requirements === null) return;
+		this._requirements.push(value);
+	}
+	_getFormattedValue(data, namedArgs, handlebars) {
+		let { value } = data;
+		const { escape = true } = namedArgs;
+		if (escape) value = handlebars.Utils.escapeExpression(value);
+		return value;
+	}
+	_getMediaData(media, args, namedArgs) {
+		const type = args[0];
+		switch (type) {
+			case "audio": return this._getSimpleMediaData(media, "audio");
+			case "screenshot": return this._getSimpleMediaData(media, "screenshot");
+			case "clipboardImage": return this._getSimpleMediaData(media, "clipboardImage");
+			case "clipboardText": return this._getSimpleMediaData(media, "clipboardText");
+			case "popupSelectionText": return this._getSimpleMediaData(media, "popupSelectionText");
+			case "textFurigana": return this._getTextFurigana(media, args[1], namedArgs, "furiganaHtml");
+			case "textFuriganaPlain": return this._getTextFurigana(media, args[1], namedArgs, "furiganaPlain");
+			case "dictionaryMedia": return this._getDictionaryMedia(media, args[1], namedArgs);
+			default: return null;
+		}
+	}
+	_getSimpleMediaData(media, type) {
+		const result = media[type];
+		if (typeof result === "object" && result !== null) return result;
+		this._addRequirement({ type });
+		return null;
+	}
+	_getDictionaryMedia(media, path, namedArgs) {
+		if (typeof path !== "string") return null;
+		const { dictionaryMedia } = media;
+		const { dictionary } = namedArgs;
+		if (typeof dictionary !== "string") return null;
+		if (typeof dictionaryMedia !== "undefined" && Object.prototype.hasOwnProperty.call(dictionaryMedia, dictionary)) {
+			const dictionaryMedia2 = dictionaryMedia[dictionary];
+			if (Object.prototype.hasOwnProperty.call(dictionaryMedia2, path)) {
+				const result = dictionaryMedia2[path];
+				if (typeof result === "object" && result !== null) return result;
+			}
+		}
+		this._addRequirement({
+			type: "dictionaryMedia",
+			dictionary,
+			path
+		});
+		return null;
+	}
+	_getTextFurigana(media, text, namedArgs, furiganaFormat) {
+		if (typeof text !== "string") return null;
+		const readingMode = this._normalizeReadingMode(namedArgs.readingMode);
+		const { textFurigana } = media;
+		if (Array.isArray(textFurigana)) for (const entry of textFurigana) {
+			if (entry.text !== text || entry.readingMode !== readingMode) continue;
+			switch (furiganaFormat) {
+				case "furiganaHtml": return entry.detailsHtml;
+				case "furiganaPlain": return entry.detailsPlain;
+			}
+		}
+		this._addRequirement({
+			type: "textFurigana",
+			text,
+			readingMode
+		});
+		return null;
+	}
+	_normalizeReadingMode(value) {
+		switch (value) {
+			case "hiragana":
+			case "katakana": return value;
+			default: return null;
+		}
+	}
+};
+var TemplateRendererCore = class {
+	_cache;
+	_cacheMaxSize;
+	_dataTypes;
+	_renderSetup;
+	_renderCleanup;
+	_handlebars;
+	constructor(handlebars) {
+		this._cache = new Map();
+		this._cacheMaxSize = 5;
+		this._dataTypes = new Map();
+		this._renderSetup = null;
+		this._renderCleanup = null;
+		this._handlebars = handlebars;
+	}
+	registerHelpers(helpers) {
+		for (const [name, helper] of helpers) this._registerHelper(name, helper);
+	}
+	registerDataType(name, details) {
+		this._dataTypes.set(name, details);
+	}
+	setRenderCallbacks(setup, cleanup) {
+		this._renderSetup = setup;
+		this._renderCleanup = cleanup;
+	}
+	render(template, data, type) {
+		const instance = this._getTemplateInstance(template);
+		const modifiedData = this._getModifiedData(data, void 0, type);
+		return this._renderTemplate(instance, modifiedData);
+	}
+	renderMulti(items) {
+		const results = [];
+		for (const { template, templateItems } of items) {
+			const instance = this._getTemplateInstance(template);
+			for (const { type, commonData, datas } of templateItems) for (const data of datas) {
+				let result;
+				try {
+					const data2 = this._getModifiedData(data, commonData, type);
+					const renderResult = this._renderTemplate(instance, data2);
+					result = { result: renderResult };
+				} catch (error) {
+					const e = error instanceof Error ? error : new Error(`${error}`);
+					result = { error: {
+						name: e.name,
+						message: e.message,
+						stack: e.stack
+					} };
+				}
+				results.push(result);
+			}
+		}
+		return results;
+	}
+	getModifiedData(data, type) {
+		return this._getModifiedData(data, void 0, type);
+	}
+	_getTemplateInstance(template) {
+		const cache = this._cache;
+		let instance = cache.get(template);
+		if (typeof instance === "undefined") {
+			this._updateCacheSize(this._cacheMaxSize - 1);
+			instance = this._handlebars.compileAST(template);
+			cache.set(template, instance);
+		}
+		return instance;
+	}
+	_renderTemplate(instance, data) {
+		const renderSetup = this._renderSetup;
+		const renderCleanup = this._renderCleanup;
+		let result;
+		let additions1;
+		try {
+			additions1 = typeof renderSetup === "function" ? renderSetup(data) : null;
+			result = instance(data).replace(/^\n+|\n+$/g, "");
+		} finally {
+			if (typeof renderCleanup === "function") renderCleanup(data);
+		}
+		return {
+			result,
+			requirements: additions1?.requirements ?? []
+		};
+	}
+	_getModifiedData(data, commonData, type) {
+		if (typeof type === "string") {
+			const typeInfo = this._dataTypes.get(type);
+			if (typeof typeInfo !== "undefined") {
+				let compositeData;
+				if (typeof commonData !== "undefined") compositeData = typeInfo.composeData(data, commonData);
+				else if (typeof data.commonData === "undefined") throw new Error("Incomplete data");
+				else compositeData = data;
+				return typeInfo.modifier(compositeData);
+			}
+		}
+		throw new Error(`Invalid type: ${type}`);
+	}
+	_updateCacheSize(maxSize) {
+		const cache = this._cache;
+		let removeCount = cache.size - maxSize;
+		if (removeCount <= 0) return;
+		for (const key of cache.keys()) {
+			cache.delete(key);
+			if (--removeCount <= 0) break;
+		}
+	}
+	_registerHelper(name, helper) {
+		const wrapper = function(...args) {
+			const argCountM1 = Math.max(0, args.length - 1);
+			const options = args[argCountM1];
+			args.length = argCountM1;
+			return helper(args, this, options);
+		};
+		this._handlebars.registerHelper(name, wrapper);
+	}
+};
+/**
+* This class contains all Anki-specific template rendering functionality.
+* It registers all 25+ Handlebars helpers and provides template rendering.
+*
+* Requires a Handlebars-compatible engine to be injected via the constructor.
+*/
+var AnkiTemplateRenderer = class {
+	_templateRenderer;
+	_mediaProvider;
+	_stateStack;
+	_requirements;
+	_cleanupCallbacks;
+	_handlebars;
+	constructor(handlebars) {
+		this._handlebars = handlebars;
+		this._templateRenderer = new TemplateRendererCore(handlebars);
+		this._mediaProvider = new TemplateRendererMediaProvider();
+		this._stateStack = null;
+		this._requirements = null;
+		this._cleanupCallbacks = [];
+	}
+	/**
+	* Gets the core TemplateRenderer instance.
+	*/
+	get templateRenderer() {
+		return this._templateRenderer;
+	}
+	/**
+	* Prepares the renderer by registering all Handlebars helpers and data types.
+	*/
+	async prepare() {
+		this._templateRenderer.registerHelpers([
+			["dumpObject", this._dumpObject.bind(this)],
+			["furigana", this._furigana.bind(this)],
+			["furiganaPlain", this._furiganaPlain.bind(this)],
+			["multiLine", this._multiLine.bind(this)],
+			["regexReplace", this._regexReplace.bind(this)],
+			["regexMatch", this._regexMatch.bind(this)],
+			["mergeTags", this._mergeTags.bind(this)],
+			["eachUpTo", this._eachUpTo.bind(this)],
+			["spread", this._spread.bind(this)],
+			["op", this._op.bind(this)],
+			["get", this._get.bind(this)],
+			["set", this._set.bind(this)],
+			["scope", this._scope.bind(this)],
+			["property", this._property.bind(this)],
+			["noop", this._noop.bind(this)],
+			["isMoraPitchHigh", this._isMoraPitchHigh.bind(this)],
+			["getKanaMorae", this._getKanaMorae.bind(this)],
+			["typeof", this._getTypeof.bind(this)],
+			["join", this._join.bind(this)],
+			["concat", this._concat.bind(this)],
+			["pitchCategories", this._pitchCategories.bind(this)],
+			["formatGlossary", this._formatGlossary.bind(this)],
+			["hasMedia", this._hasMedia.bind(this)],
+			["getMedia", this._getMedia.bind(this)],
+			["hiragana", this._hiragana.bind(this)],
+			["katakana", this._katakana.bind(this)]
+		]);
+		this._templateRenderer.registerDataType("ankiNote", {
+			modifier: ({ marker, commonData }) => createAnkiNoteData(marker, commonData),
+			composeData: ({ marker }, commonData) => ({
+				marker,
+				commonData
+			})
+		});
+		this._templateRenderer.setRenderCallbacks(this._onRenderSetup.bind(this), this._onRenderCleanup.bind(this));
+	}
+	/**
+	* Renders a single template with given data.
+	*/
+	render(template, data, type) {
+		return this._templateRenderer.render(template, data, type);
+	}
+	/**
+	* Renders multiple templates with given data.
+	*/
+	renderMulti(items) {
+		return this._templateRenderer.renderMulti(items);
+	}
+	/**
+	* Gets modified data for a given type.
+	*/
+	getModifiedData(data, type) {
+		return this._templateRenderer.getModifiedData(data, type);
+	}
+	_onRenderSetup() {
+		const requirements = [];
+		this._stateStack = [new Map()];
+		this._requirements = requirements;
+		this._mediaProvider.requirements = requirements;
+		return { requirements };
+	}
+	_onRenderCleanup() {
+		for (const callback of this._cleanupCallbacks) callback();
+		this._stateStack = null;
+		this._requirements = null;
+		this._mediaProvider.requirements = null;
+		this._cleanupCallbacks.length = 0;
+	}
+	_safeString(text) {
+		return new this._handlebars.SafeString(text);
+	}
+	_dumpObject(args) {
+		return JSON.stringify(args[0], null, 4);
+	}
+	_furigana(args, context, options) {
+		const { expression, reading } = this._getFuriganaExpressionAndReading(args);
+		const segments = distributeFurigana(expression, reading);
+		let result = "";
+		for (const { text, reading: reading2 } of segments) result += reading2.length > 0 ? `<ruby>${text}<rt>${reading2}</rt></ruby>` : text;
+		return this._safeString(result);
+	}
+	_furiganaPlain(args) {
+		const { expression, reading } = this._getFuriganaExpressionAndReading(args);
+		const segments = distributeFurigana(expression, reading);
+		let result = "";
+		for (const { text, reading: reading2 } of segments) if (reading2.length > 0) {
+			if (result.length > 0) result += " ";
+			result += `${text}[${reading2}]`;
+		} else result += text;
+		return result;
+	}
+	_getFuriganaExpressionAndReading(args) {
+		let expression;
+		let reading;
+		if (args.length >= 2) [expression, reading] = args;
+		else {
+			const obj = args[0];
+			({expression, reading} = obj);
+		}
+		return {
+			expression: typeof expression === "string" ? expression : "",
+			reading: typeof reading === "string" ? reading : ""
+		};
+	}
+	_stringToMultiLineHtml(string) {
+		return string.split("\n").join("<br>");
+	}
+	_multiLine(_args, context, options) {
+		return this._safeString(this._stringToMultiLineHtml(this._computeValueString(options, context)));
+	}
+	_regexReplace(args, context, options) {
+		const argCount = args.length;
+		let value = this._computeValueString(options, context);
+		if (argCount > 3) value = `${args.slice(3).join("")}${value}`;
+		if (argCount > 1) try {
+			const [pattern, replacement, flags] = args;
+			if (typeof pattern !== "string") throw new Error("Invalid pattern");
+			if (typeof replacement !== "string") throw new Error("Invalid replacement");
+			const regex = new RegExp(pattern, typeof flags === "string" ? flags : "g");
+			value = value.replace(regex, replacement);
+		} catch (e) {
+			return `${e}`;
+		}
+		return value;
+	}
+	_regexMatch(args, context, options) {
+		const argCount = args.length;
+		let value = this._computeValueString(options, context);
+		if (argCount > 2) value = `${args.slice(2).join("")}${value}`;
+		if (argCount > 0) try {
+			const [pattern, flags] = args;
+			if (typeof pattern !== "string") throw new Error("Invalid pattern");
+			const regex = new RegExp(pattern, typeof flags === "string" ? flags : "");
+			const parts = [];
+			value.replace(regex, (g0) => {
+				parts.push(g0);
+				return g0;
+			});
+			value = parts.join("");
+		} catch (e) {
+			return `${e}`;
+		}
+		return value;
+	}
+	_mergeTags(args) {
+		const [object, isGroupMode, isMergeMode] = args;
+		const tagSources = [];
+		if (Array.isArray(object.termTags)) tagSources.push(object.termTags);
+		if (isGroupMode || isMergeMode) {
+			const { definitions } = object;
+			if (Array.isArray(definitions)) for (const definition of definitions) tagSources.push(definition.definitionTags);
+		} else if (Array.isArray(object.definitionTags)) tagSources.push(object.definitionTags);
+		const tags = new Set();
+		for (const tagSource of tagSources) for (const tag of tagSource) tags.add(tag.name);
+		return [...tags].join(", ");
+	}
+	_eachUpTo(args, context, options) {
+		const [iterable, maxCount] = args;
+		if (iterable) {
+			const results = [];
+			let any = false;
+			for (const entry of iterable) {
+				any = true;
+				if (results.length >= maxCount) break;
+				const processedEntry = this._computeValue(options, entry);
+				results.push(`${processedEntry}`);
+			}
+			if (any) return results.join("");
+		}
+		return this._computeInverseString(options, context);
+	}
+	_spread(args) {
+		const result = [];
+		for (const array of args) try {
+			result.push(...array);
+		} catch (_e) {}
+		return result;
+	}
+	_op(args) {
+		const [operator] = args;
+		switch (args.length) {
+			case 2: return this._evaluateUnaryExpression(operator, args[1]);
+			case 3: return this._evaluateBinaryExpression(operator, args[1], args[2]);
+			case 4: return this._evaluateTernaryExpression(operator, args[1], args[2], args[3]);
+			default: return void 0;
+		}
+	}
+	_evaluateUnaryExpression(operator, operand1) {
+		switch (operator) {
+			case "+": return +operand1;
+			case "-": return -operand1;
+			case "~": return ~operand1;
+			case "!": return !operand1;
+			default: return void 0;
+		}
+	}
+	_evaluateBinaryExpression(operator, operand1, operand2) {
+		switch (operator) {
+			case "+": return operand1 + operand2;
+			case "-": return operand1 - operand2;
+			case "/": return operand1 / operand2;
+			case "*": return operand1 * operand2;
+			case "%": return operand1 % operand2;
+			case "**": return operand1 ** operand2;
+			case "==": return operand1 === operand2;
+			case "!=": return operand1 !== operand2;
+			case "===": return operand1 === operand2;
+			case "!==": return operand1 !== operand2;
+			case "<": return operand1 < operand2;
+			case "<=": return operand1 <= operand2;
+			case ">": return operand1 > operand2;
+			case ">=": return operand1 >= operand2;
+			case "<<": return operand1 << operand2;
+			case ">>": return operand1 >> operand2;
+			case ">>>": return operand1 >>> operand2;
+			case "&": return operand1 & operand2;
+			case "|": return operand1 | operand2;
+			case "^": return operand1 ^ operand2;
+			case "&&": return operand1 && operand2;
+			case "||": return operand1 || operand2;
+			default: return void 0;
+		}
+	}
+	_evaluateTernaryExpression(operator, operand1, operand2, operand3) {
+		switch (operator) {
+			case "?:": return operand1 ? operand2 : operand3;
+			default: return void 0;
+		}
+	}
+	_get(args) {
+		const [key] = args;
+		const stateStack = this._stateStack;
+		if (stateStack === null) throw new Error("Invalid state");
+		for (let i = stateStack.length; --i >= 0;) {
+			const map = stateStack[i];
+			if (map.has(key)) return map.get(key);
+		}
+		return void 0;
+	}
+	_set(args, context, options) {
+		const stateStack = this._stateStack;
+		if (stateStack === null) throw new Error("Invalid state");
+		switch (args.length) {
+			case 1:
+				{
+					const [key] = args;
+					const value = this._computeValue(options, context);
+					stateStack[stateStack.length - 1].set(key, value);
+				}
+				break;
+			case 2:
+				{
+					const [key, value] = args;
+					stateStack[stateStack.length - 1].set(key, value);
+				}
+				break;
+		}
+		return "";
+	}
+	_scope(_args, context, options) {
+		const stateStack = this._stateStack;
+		if (stateStack === null) throw new Error("Invalid state");
+		try {
+			stateStack.push(new Map());
+			return this._computeValue(options, context);
+		} finally {
+			if (stateStack.length > 1) stateStack.pop();
+		}
+	}
+	_property(args) {
+		const ii = args.length;
+		if (ii <= 0) return void 0;
+		try {
+			let value = args[0];
+			for (let i = 1; i < ii; ++i) {
+				if (typeof value !== "object" || value === null) throw new Error("Invalid object");
+				const key = args[i];
+				switch (typeof key) {
+					case "number":
+					case "string":
+					case "symbol": break;
+					default: throw new Error("Invalid key");
+				}
+				value = value[key];
+			}
+			return value;
+		} catch (_e) {
+			return void 0;
+		}
+	}
+	_noop(_args, context, options) {
+		return this._computeValue(options, context);
+	}
+	_isMoraPitchHigh(args) {
+		const [index, position] = args;
+		return isMoraPitchHigh(index, position);
+	}
+	_getKanaMorae(args) {
+		const [text] = args;
+		return getKanaMorae(`${text}`);
+	}
+	_getTypeof(args, context, options) {
+		const ii = args.length;
+		const value = ii > 0 ? args[0] : this._computeValue(options, context);
+		return typeof value;
+	}
+	_join(args) {
+		return args.length > 0 ? args.slice(1, args.length).flat().join(args[0]) : "";
+	}
+	_concat(args) {
+		let result = "";
+		for (let i = 0, ii = args.length; i < ii; ++i) result += args[i];
+		return result;
+	}
+	_pitchCategories(args) {
+		const [data] = args;
+		const { dictionaryEntry } = data;
+		if (dictionaryEntry.type !== "term") return [];
+		const { pronunciations: termPronunciations, headwords } = dictionaryEntry;
+		const categories = new Set();
+		for (const { headwordIndex, pronunciations } of termPronunciations) {
+			const { reading, wordClasses } = headwords[headwordIndex];
+			const isVerbOrAdjective = isNonNounVerbOrAdjective(wordClasses);
+			const pitches = getPronunciationsOfType(pronunciations, "pitch-accent");
+			for (const { positions } of pitches) {
+				const category = getPitchCategory(reading, positions, isVerbOrAdjective);
+				if (category !== null) categories.add(category);
+			}
+		}
+		return [...categories];
+	}
+	_formatGlossary(args, _context, options) {
+		const [_dictionary, content] = args;
+		if (typeof content === "string") return this._safeString(this._stringToMultiLineHtml(content));
+		if (!(typeof content === "object" && content !== null)) return "";
+		switch (content.type) {
+			case "text": return this._safeString(this._stringToMultiLineHtml(content.text));
+			case "image": return "";
+			case "structured-content": return this._safeString("[structured content]");
+		}
+		return "";
+	}
+	_hasMedia(args, _context, options) {
+		const data = this._getNoteDataFromOptions(options);
+		return this._mediaProvider.hasMedia(data, args, options.hash);
+	}
+	_getMedia(args, _context, options) {
+		const data = this._getNoteDataFromOptions(options);
+		return this._mediaProvider.getMedia(data, args, options.hash, this._handlebars);
+	}
+	_hiragana(args, context, options) {
+		const ii = args.length;
+		const value = ii > 0 ? args[0] : this._computeValue(options, context);
+		return typeof value === "string" ? convertKatakanaToHiragana(value) : "";
+	}
+	_katakana(args, context, options) {
+		const ii = args.length;
+		const value = ii > 0 ? args[0] : this._computeValue(options, context);
+		return typeof value === "string" ? convertHiraganaToKatakana(value) : "";
+	}
+	_getNoteDataFromOptions(options) {
+		return options.data.root;
+	}
+	_asString(value) {
+		return typeof value === "string" ? value : `${value}`;
+	}
+	_computeValue(options, context) {
+		return typeof options.fn === "function" ? options.fn(context) : "";
+	}
+	_computeValueString(options, context) {
+		return this._asString(this._computeValue(options, context));
+	}
+	_computeInverse(options, context) {
+		return typeof options.inverse === "function" ? options.inverse(context) : "";
+	}
+	_computeInverseString(options, context) {
+		return this._asString(this._computeInverse(options, context));
+	}
+};
+const HIRAGANA_CONVERSION_RANGE = [12353, 12438];
+const KATAKANA_CONVERSION_RANGE = [12449, 12534];
+const KANA_PROLONGED_SOUND_MARK_CODE_POINT = 12540;
+function convertKatakanaToHiragana(text, keepProlongedSoundMarks = false) {
+	let result = "";
+	const offset = HIRAGANA_CONVERSION_RANGE[0] - KATAKANA_CONVERSION_RANGE[0];
+	for (const char of text) {
+		const codePoint = char.codePointAt(0);
+		if (codePoint === KANA_PROLONGED_SOUND_MARK_CODE_POINT && !keepProlongedSoundMarks) result += char;
+		else if (codePoint >= KATAKANA_CONVERSION_RANGE[0] && codePoint <= KATAKANA_CONVERSION_RANGE[1]) result += String.fromCodePoint(codePoint + offset);
+		else result += char;
+	}
+	return result;
+}
+function convertHiraganaToKatakana(text) {
+	let result = "";
+	const offset = KATAKANA_CONVERSION_RANGE[0] - HIRAGANA_CONVERSION_RANGE[0];
+	for (const char of text) {
+		const codePoint = char.codePointAt(0);
+		if (codePoint >= HIRAGANA_CONVERSION_RANGE[0] && codePoint <= HIRAGANA_CONVERSION_RANGE[1]) result += String.fromCodePoint(codePoint + offset);
+		else result += char;
+	}
+	return result;
+}
+function isMoraPitchHigh(moraIndex, pitchAccentPosition) {
+	const pos = typeof pitchAccentPosition === "string" ? Number.parseInt(pitchAccentPosition, 10) : pitchAccentPosition;
+	if (pos === 0) return moraIndex > 0;
+	if (moraIndex === 0) return pos > 1;
+	return moraIndex < pos;
+}
+function getKanaMorae(text) {
+	const morae = [];
+	const SMALL_KANA_SET = new Set("ぁぃぅぇぉゃゅょゎァィゥェォャュョヮ");
+	for (const char of text) if (morae.length > 0 && SMALL_KANA_SET.has(char)) morae[morae.length - 1] += char;
+	else morae.push(char);
+	return morae;
+}
+function getPitchCategory(reading, positions, isVerbOrAdjective) {
+	const pos = typeof positions === "string" ? Number.parseInt(positions, 10) : positions;
+	if (pos === 0) return "heiban";
+	if (pos === 1) return "atamadaka";
+	const morae = getKanaMorae(reading);
+	if (pos >= morae.length) return isVerbOrAdjective ? "kifuku" : "odaka";
+	return isVerbOrAdjective ? "kifuku" : "nakadaka";
+}
+
+//#endregion
+export { AnkiConnect, AnkiNoteBuilder, AnkiTemplateRenderer, createAnkiNoteData, createCachedValue, getCachedValue, getFrequencyHarmonic };
+//# sourceMappingURL=anki.js.map