yomitan-core 0.1.0

package/dist/display-generator-DyP-HNzP.cjs

@@ -0,0 +1,758 @@
+"use strict";
+const require_dictionary_data_util = require('./dictionary-data-util-CHnRdYZ9.cjs');
+const require_furigana = require('./furigana-DpZLcues.cjs');
+const require_text_utilities = require('./text-utilities-Del2Ivkg.cjs');
+const require_pronunciation_generator = require('./pronunciation-generator-CFbZlf5J.cjs');
+const require_structured_content_generator = require('./structured-content-generator-DrwkB0-k.cjs');
+
+//#region src/render/html-template-collection.ts
+/**
+* A collection of HTML templates parsed from raw HTML strings.
+* Templates are identified by their `id` attribute, which must end with `-template`.
+* The prefix before `-template` is used as the template name.
+*/
+var HtmlTemplateCollection = class {
+	_templates;
+	_document;
+	/**
+	* Creates a new HtmlTemplateCollection.
+	* @param doc - The Document object to use for DOM operations.
+	*/
+	constructor(doc) {
+		this._templates = new Map();
+		this._document = doc;
+	}
+	/**
+	* Loads templates from a raw HTML string.
+	* @param html - The HTML string containing `<template>` elements.
+	*/
+	loadFromString(html) {
+		const parser = new this._document.defaultView.DOMParser();
+		const templatesDocument = parser.parseFromString(html, "text/html");
+		this.load(templatesDocument);
+	}
+	/**
+	* Loads templates from a Document source.
+	* @param source - The Document containing template elements.
+	*/
+	load(source) {
+		const pattern = /^([\w\W]+)-template$/;
+		for (const template of Array.from(source.querySelectorAll("template"))) {
+			const match = pattern.exec(template.id);
+			if (match === null) continue;
+			this._prepareTemplate(template);
+			this._templates.set(match[1], template);
+		}
+	}
+	/**
+	* Instantiates a template by name, returning the first element child as a deep clone.
+	* @param name - The template name (without the `-template` suffix).
+	* @returns The cloned first element child.
+	* @throws Error if the template or its content element is not found.
+	*/
+	instantiate(name) {
+		const { firstElementChild } = this.getTemplateContent(name);
+		if (firstElementChild === null) throw new Error(`Failed to find template content element: ${name}`);
+		return this._document.importNode(firstElementChild, true);
+	}
+	/**
+	* Instantiates a template by name, returning the entire content as a DocumentFragment clone.
+	* @param name - The template name (without the `-template` suffix).
+	* @returns The cloned DocumentFragment.
+	*/
+	instantiateFragment(name) {
+		return this._document.importNode(this.getTemplateContent(name), true);
+	}
+	/**
+	* Gets the content DocumentFragment of a named template.
+	* @param name - The template name (without the `-template` suffix).
+	* @returns The template's content DocumentFragment.
+	* @throws Error if the template is not found.
+	*/
+	getTemplateContent(name) {
+		const template = this._templates.get(name);
+		if (typeof template === "undefined") throw new Error(`Failed to find template: ${name}`);
+		return template.content;
+	}
+	/**
+	* Returns an iterator over all template elements.
+	*/
+	getAllTemplates() {
+		return this._templates.values();
+	}
+	_prepareTemplate(template) {
+		if (template.dataset.removeWhitespaceText === "true") this._removeWhitespaceText(template);
+	}
+	_removeWhitespaceText(template) {
+		const { content } = template;
+		const { TEXT_NODE } = this._document.defaultView ? this._document.defaultView.Node : { TEXT_NODE: 3 };
+		const iterator = this._document.createNodeIterator(
+			content,
+			4
+			/* NodeFilter.SHOW_TEXT */
+);
+		const removeNodes = [];
+		while (true) {
+			const node = iterator.nextNode();
+			if (node === null) break;
+			if (node.nodeType === TEXT_NODE && (node.nodeValue ?? "").trim().length === 0) removeNodes.push(node);
+		}
+		for (const node of removeNodes) {
+			const { parentNode } = node;
+			if (parentNode !== null) parentNode.removeChild(node);
+		}
+	}
+};
+
+//#endregion
+//#region src/render/display-generator.ts
+/**
+* Generates DOM elements for displaying dictionary entries.
+* This is the main rendering class that creates term entries, kanji entries,
+* and all associated sub-elements (headwords, definitions, tags, frequencies, etc.).
+*/
+var DisplayGenerator = class {
+	_contentManager;
+	_templates;
+	_structuredContentGenerator;
+	_pronunciationGenerator;
+	_language;
+	_document;
+	/**
+	* Creates a new DisplayGenerator.
+	* @param doc - The Document object to use for DOM operations.
+	* @param contentManager - The content manager for loading media.
+	* @param templateHtml - The HTML string containing display templates.
+	*/
+	constructor(doc, contentManager, templateHtml) {
+		this._document = doc;
+		this._contentManager = contentManager;
+		this._templates = new HtmlTemplateCollection(doc);
+		this._templates.loadFromString(templateHtml);
+		this._structuredContentGenerator = new require_structured_content_generator.StructuredContentGenerator(this._contentManager, doc);
+		this._pronunciationGenerator = new require_pronunciation_generator.PronunciationGenerator(doc);
+		this._language = "ja";
+	}
+	/** The current content manager. */
+	get contentManager() {
+		return this._contentManager;
+	}
+	set contentManager(contentManager) {
+		this._contentManager = contentManager;
+	}
+	/**
+	* Updates the target language for rendering.
+	* @param language - The BCP 47 language tag (e.g. 'ja', 'zh').
+	*/
+	updateLanguage(language) {
+		this._language = language;
+	}
+	/**
+	* Creates a complete term entry element from a dictionary entry.
+	* @param dictionaryEntry - The term dictionary entry data.
+	* @param dictionaryInfo - Array of dictionary summary information.
+	* @returns An HTMLElement representing the full term entry.
+	*/
+	createTermEntry(dictionaryEntry, dictionaryInfo) {
+		const node = this._instantiate("term-entry");
+		const headwordsContainer = this._querySelector(node, ".headword-list");
+		const inflectionRuleChainsContainer = this._querySelector(node, ".inflection-rule-chains");
+		const groupedPronunciationsContainer = this._querySelector(node, ".pronunciation-group-list");
+		const frequencyGroupListContainer = this._querySelector(node, ".frequency-group-list");
+		const definitionsContainer = this._querySelector(node, ".definition-list");
+		const headwordTagsContainer = this._querySelector(node, ".headword-list-tag-list");
+		const { headwords, type, inflectionRuleChainCandidates, definitions, frequencies, pronunciations } = dictionaryEntry;
+		const groupedPronunciations = require_dictionary_data_util.getGroupedPronunciations(dictionaryEntry);
+		const pronunciationCount = groupedPronunciations.reduce((i, v) => i + v.pronunciations.length, 0);
+		const groupedFrequencies = require_dictionary_data_util.groupTermFrequencies(dictionaryEntry, dictionaryInfo);
+		const termTags = require_dictionary_data_util.groupTermTags(dictionaryEntry);
+		const uniqueTerms = new Set();
+		const uniqueReadings = new Set();
+		const primaryMatchTypes = new Set();
+		for (const { term, reading, sources } of headwords) {
+			uniqueTerms.add(term);
+			uniqueReadings.add(reading);
+			for (const { matchType, isPrimary } of sources) {
+				if (!isPrimary) continue;
+				primaryMatchTypes.add(matchType);
+			}
+		}
+		node.dataset.format = type;
+		node.dataset.headwordCount = `${headwords.length}`;
+		node.dataset.definitionCount = `${definitions.length}`;
+		node.dataset.pronunciationDictionaryCount = `${groupedPronunciations.length}`;
+		node.dataset.pronunciationCount = `${pronunciationCount}`;
+		node.dataset.uniqueTermCount = `${uniqueTerms.size}`;
+		node.dataset.uniqueReadingCount = `${uniqueReadings.size}`;
+		node.dataset.frequencyCount = `${frequencies.length}`;
+		node.dataset.groupedFrequencyCount = `${groupedFrequencies.length}`;
+		node.dataset.primaryMatchTypes = [...primaryMatchTypes].join(" ");
+		for (let i = 0, ii = headwords.length; i < ii; ++i) {
+			const node2 = this._createTermHeadword(headwords[i], i, pronunciations);
+			node2.dataset.index = `${i}`;
+			headwordsContainer.appendChild(node2);
+		}
+		headwordsContainer.dataset.count = `${headwords.length}`;
+		this._appendMultiple(inflectionRuleChainsContainer, this._createInflectionRuleChain.bind(this), inflectionRuleChainCandidates);
+		this._appendMultiple(frequencyGroupListContainer, this._createFrequencyGroup.bind(this), groupedFrequencies, false);
+		this._appendMultiple(groupedPronunciationsContainer, this._createGroupedPronunciation.bind(this), groupedPronunciations);
+		this._appendMultiple(headwordTagsContainer, this._createTermTag.bind(this), termTags, headwords.length);
+		for (const term of uniqueTerms) headwordTagsContainer.appendChild(this._createSearchTag(term));
+		for (const reading of uniqueReadings) {
+			if (uniqueTerms.has(reading)) continue;
+			headwordTagsContainer.appendChild(this._createSearchTag(reading));
+		}
+		const dictionaryTag = this._createDictionaryTag("");
+		for (let i = 0, ii = definitions.length; i < ii; ++i) {
+			const definition = definitions[i];
+			const { dictionary, dictionaryAlias } = definition;
+			if (dictionaryTag.dictionaries.includes(dictionary)) dictionaryTag.redundant = true;
+			else {
+				dictionaryTag.redundant = false;
+				dictionaryTag.dictionaries.push(dictionary);
+				dictionaryTag.name = dictionaryAlias;
+				dictionaryTag.content = [dictionary];
+				const currentDictionaryInfo = dictionaryInfo.find(({ title }) => title === dictionary);
+				if (currentDictionaryInfo) {
+					const dictionaryContentArray = [];
+					dictionaryContentArray.push(currentDictionaryInfo.title);
+					if (currentDictionaryInfo.author) dictionaryContentArray.push(`Author: ${currentDictionaryInfo.author}`);
+					if (currentDictionaryInfo.description) dictionaryContentArray.push(`Description: ${currentDictionaryInfo.description}`);
+					if (currentDictionaryInfo.url) dictionaryContentArray.push(`URL: ${currentDictionaryInfo.url}`);
+					const totalTerms = currentDictionaryInfo?.counts?.terms?.total;
+					if (totalTerms !== void 0 && totalTerms > 0) dictionaryContentArray.push(`Term Count: ${totalTerms.toString()}`);
+					dictionaryTag.content = dictionaryContentArray;
+				}
+			}
+			const node2 = this._createTermDefinition(definition, dictionaryTag, headwords, uniqueTerms, uniqueReadings);
+			node2.dataset.index = `${i}`;
+			definitionsContainer.appendChild(node2);
+		}
+		definitionsContainer.dataset.count = `${definitions.length}`;
+		return node;
+	}
+	/**
+	* Creates a complete kanji entry element from a dictionary entry.
+	* @param dictionaryEntry - The kanji dictionary entry data.
+	* @param dictionaryInfo - Array of dictionary summary information.
+	* @returns An HTMLElement representing the full kanji entry.
+	*/
+	createKanjiEntry(dictionaryEntry, dictionaryInfo) {
+		const node = this._instantiate("kanji-entry");
+		node.dataset.dictionary = dictionaryEntry.dictionary;
+		const glyphContainer = this._querySelector(node, ".kanji-glyph");
+		const frequencyGroupListContainer = this._querySelector(node, ".frequency-group-list");
+		const tagContainer = this._querySelector(node, ".kanji-tag-list");
+		const definitionsContainer = this._querySelector(node, ".kanji-gloss-list");
+		const chineseReadingsContainer = this._querySelector(node, ".kanji-readings-chinese");
+		const japaneseReadingsContainer = this._querySelector(node, ".kanji-readings-japanese");
+		const statisticsContainer = this._querySelector(node, ".kanji-statistics");
+		const classificationsContainer = this._querySelector(node, ".kanji-classifications");
+		const codepointsContainer = this._querySelector(node, ".kanji-codepoints");
+		const dictionaryIndicesContainer = this._querySelector(node, ".kanji-dictionary-indices");
+		this._setTextContent(glyphContainer, dictionaryEntry.character, this._language);
+		if (this._language === "ja") glyphContainer.style.fontFamily = "kanji-stroke-orders, sans-serif";
+		const groupedFrequencies = require_dictionary_data_util.groupKanjiFrequencies(dictionaryEntry.frequencies, dictionaryInfo);
+		const dictionaryTag = this._createDictionaryTag("");
+		dictionaryTag.name = dictionaryEntry.dictionaryAlias;
+		dictionaryTag.content = [dictionaryEntry.dictionary];
+		const currentDictionaryInfo = dictionaryInfo.find(({ title }) => title === dictionaryEntry.dictionary);
+		if (currentDictionaryInfo) {
+			const dictionaryContentArray = [];
+			dictionaryContentArray.push(currentDictionaryInfo.title);
+			if (currentDictionaryInfo.author) dictionaryContentArray.push(`Author: ${currentDictionaryInfo.author}`);
+			if (currentDictionaryInfo.description) dictionaryContentArray.push(`Description: ${currentDictionaryInfo.description}`);
+			if (currentDictionaryInfo.url) dictionaryContentArray.push(`URL: ${currentDictionaryInfo.url}`);
+			const totalKanji = currentDictionaryInfo?.counts?.kanji?.total;
+			if (totalKanji !== void 0 && totalKanji > 0) dictionaryContentArray.push(`Kanji Count: ${totalKanji.toString()}`);
+			dictionaryTag.content = dictionaryContentArray;
+		}
+		this._appendMultiple(frequencyGroupListContainer, this._createFrequencyGroup.bind(this), groupedFrequencies, true);
+		this._appendMultiple(tagContainer, this._createTag.bind(this), [...dictionaryEntry.tags, dictionaryTag]);
+		this._appendMultiple(definitionsContainer, this._createKanjiDefinition.bind(this), dictionaryEntry.definitions);
+		this._appendMultiple(chineseReadingsContainer, this._createKanjiReading.bind(this), dictionaryEntry.onyomi);
+		this._appendMultiple(japaneseReadingsContainer, this._createKanjiReading.bind(this), dictionaryEntry.kunyomi);
+		statisticsContainer.appendChild(this._createKanjiInfoTable(dictionaryEntry.stats.misc));
+		classificationsContainer.appendChild(this._createKanjiInfoTable(dictionaryEntry.stats.class));
+		codepointsContainer.appendChild(this._createKanjiInfoTable(dictionaryEntry.stats.code));
+		dictionaryIndicesContainer.appendChild(this._createKanjiInfoTable(dictionaryEntry.stats.index));
+		return node;
+	}
+	/**
+	* Creates an empty footer notification element.
+	*/
+	createEmptyFooterNotification() {
+		return this._instantiate("footer-notification");
+	}
+	/**
+	* Instantiates a named template, returning the first element child.
+	* @param name - The template name.
+	*/
+	instantiateTemplate(name) {
+		return this._instantiate(name);
+	}
+	/**
+	* Instantiates a named template, returning the full DocumentFragment.
+	* @param name - The template name.
+	*/
+	instantiateTemplateFragment(name) {
+		return this._templates.instantiateFragment(name);
+	}
+	_createTermHeadword(headword, headwordIndex, pronunciations) {
+		const { term, reading, tags, sources } = headword;
+		let isPrimaryAny = false;
+		const matchTypes = new Set();
+		const matchSources = new Set();
+		for (const { matchType, matchSource, isPrimary } of sources) {
+			if (isPrimary) isPrimaryAny = true;
+			matchTypes.add(matchType);
+			matchSources.add(matchSource);
+		}
+		const node = this._instantiate("headword");
+		const termContainer = this._querySelector(node, ".headword-term");
+		node.dataset.isPrimary = `${isPrimaryAny}`;
+		node.dataset.readingIsSame = `${reading === term}`;
+		node.dataset.frequency = require_dictionary_data_util.getTermFrequency(tags);
+		node.dataset.matchTypes = [...matchTypes].join(" ");
+		node.dataset.matchSources = [...matchSources].join(" ");
+		const { wordClasses } = headword;
+		const pronunciationCategories = this._getPronunciationCategories(reading, pronunciations, wordClasses, headwordIndex);
+		if (pronunciationCategories !== null) node.dataset.pronunciationCategories = pronunciationCategories;
+		if (wordClasses.length > 0) node.dataset.wordClasses = wordClasses.join(" ");
+		const headwordReading = this._querySelector(node, ".headword-reading");
+		this._setTextContent(headwordReading, reading);
+		this._appendFurigana(termContainer, term, reading, this._appendKanjiLinks.bind(this));
+		return node;
+	}
+	_createInflectionRuleChain(inflectionRuleChain) {
+		const { source, inflectionRules } = inflectionRuleChain;
+		if (!Array.isArray(inflectionRules) || inflectionRules.length === 0) return null;
+		const fragment = this._instantiate("inflection-rule-chain");
+		const sourceIcon = this._getInflectionSourceIcon(source);
+		fragment.appendChild(sourceIcon);
+		this._appendMultiple(fragment, this._createTermInflection.bind(this), inflectionRules);
+		return fragment;
+	}
+	_getInflectionSourceIcon(source) {
+		const icon = this._document.createElement("span");
+		icon.classList.add("inflection-source-icon");
+		icon.dataset.inflectionSource = source;
+		switch (source) {
+			case "dictionary":
+				icon.title = "Dictionary Deinflection";
+				return icon;
+			case "algorithm":
+				icon.title = "Algorithm Deinflection";
+				return icon;
+			case "both":
+				icon.title = "Dictionary and Algorithm Deinflection";
+				return icon;
+		}
+	}
+	_createTermInflection(inflection) {
+		const { name, description } = inflection;
+		const fragment = this._templates.instantiateFragment("inflection");
+		const node = this._querySelector(fragment, ".inflection");
+		this._setTextContent(node, name);
+		if (description) node.title = description;
+		node.dataset.reason = name;
+		return fragment;
+	}
+	_createTermDefinition(definition, dictionaryTag, headwords, uniqueTerms, uniqueReadings) {
+		const { dictionary, tags, headwordIndices, entries } = definition;
+		const disambiguations = require_dictionary_data_util.getDisambiguations(headwords, headwordIndices, uniqueTerms, uniqueReadings);
+		const node = this._instantiate("definition-item");
+		const tagListContainer = this._querySelector(node, ".definition-tag-list");
+		const onlyListContainer = this._querySelector(node, ".definition-disambiguation-list");
+		const entriesContainer = this._querySelector(node, ".gloss-list");
+		node.dataset.dictionary = dictionary;
+		this._appendMultiple(tagListContainer, this._createTag.bind(this), [...tags, dictionaryTag]);
+		this._appendMultiple(onlyListContainer, this._createTermDisambiguation.bind(this), disambiguations);
+		this._appendMultiple(entriesContainer, this._createTermDefinitionEntry.bind(this), entries, dictionary);
+		return node;
+	}
+	_createTermDefinitionEntry(entry, dictionary) {
+		switch (typeof entry) {
+			case "string": return this._createTermDefinitionEntryText(entry);
+			case "object": {
+				switch (entry.type) {
+					case "image": return this._createTermDefinitionEntryImage(entry, dictionary);
+					case "structured-content": return this._createTermDefinitionEntryStructuredContent(entry.content, dictionary);
+					case "text": break;
+				}
+				break;
+			}
+		}
+		return null;
+	}
+	_createTermDefinitionEntryText(text) {
+		const node = this._instantiate("gloss-item");
+		const container = this._querySelector(node, ".gloss-content");
+		this._setMultilineTextContent(container, text);
+		return node;
+	}
+	_createTermDefinitionEntryImage(data, dictionary) {
+		const { description } = data;
+		const node = this._instantiate("gloss-item");
+		const contentContainer = this._querySelector(node, ".gloss-content");
+		const image = this._structuredContentGenerator.createDefinitionImage(data, dictionary);
+		contentContainer.appendChild(image);
+		if (typeof description === "string") {
+			const fragment = this._templates.instantiateFragment("gloss-item-image-description");
+			const container = this._querySelector(fragment, ".gloss-image-description");
+			this._setMultilineTextContent(container, description);
+			contentContainer.appendChild(fragment);
+		}
+		return node;
+	}
+	_createTermDefinitionEntryStructuredContent(content, dictionary) {
+		const node = this._instantiate("gloss-item");
+		const contentContainer = this._querySelector(node, ".gloss-content");
+		this._structuredContentGenerator.appendStructuredContent(contentContainer, content, dictionary);
+		return node;
+	}
+	_createTermDisambiguation(disambiguation) {
+		const node = this._instantiate("definition-disambiguation");
+		node.dataset.term = disambiguation;
+		this._setTextContent(node, disambiguation, this._language);
+		return node;
+	}
+	_createKanjiLink(character) {
+		const node = this._document.createElement("a");
+		node.className = "headword-kanji-link";
+		this._setTextContent(node, character, this._language);
+		return node;
+	}
+	_createKanjiDefinition(text) {
+		const node = this._instantiate("kanji-gloss-item");
+		const container = this._querySelector(node, ".kanji-gloss-content");
+		this._setMultilineTextContent(container, text);
+		return node;
+	}
+	_createKanjiReading(reading) {
+		const node = this._instantiate("kanji-reading");
+		this._setTextContent(node, reading, this._language);
+		return node;
+	}
+	_createKanjiInfoTable(details) {
+		const node = this._instantiate("kanji-info-table");
+		const container = this._querySelector(node, ".kanji-info-table-body");
+		const count = this._appendMultiple(container, this._createKanjiInfoTableItem.bind(this), details);
+		if (count === 0) {
+			const n = this._createKanjiInfoTableItemEmpty();
+			container.appendChild(n);
+		}
+		return node;
+	}
+	_createKanjiInfoTableItem(details) {
+		const { content, name, value } = details;
+		const node = this._instantiate("kanji-info-table-item");
+		const nameNode = this._querySelector(node, ".kanji-info-table-item-header");
+		const valueNode = this._querySelector(node, ".kanji-info-table-item-value");
+		this._setTextContent(nameNode, content.length > 0 ? content : name);
+		this._setTextContent(valueNode, typeof value === "string" ? value : `${value}`);
+		return node;
+	}
+	_createKanjiInfoTableItemEmpty() {
+		return this._instantiate("kanji-info-table-empty");
+	}
+	_createTag(tag) {
+		const { content, name, category, redundant } = tag;
+		const node = this._instantiate("tag");
+		const inner = this._querySelector(node, ".tag-label-content");
+		const contentString = content.join("\n");
+		node.title = contentString;
+		this._setTextContent(inner, name);
+		node.dataset.details = contentString.length > 0 ? contentString : name;
+		node.dataset.category = category;
+		if (redundant) node.dataset.redundant = "true";
+		return node;
+	}
+	_createTermTag(tagInfo, totalHeadwordCount) {
+		const { tag, headwordIndices } = tagInfo;
+		const node = this._createTag(tag);
+		node.dataset.headwords = headwordIndices.join(" ");
+		node.dataset.totalHeadwordCount = `${totalHeadwordCount}`;
+		node.dataset.matchedHeadwordCount = `${headwordIndices.length}`;
+		node.dataset.unmatchedHeadwordCount = `${Math.max(0, totalHeadwordCount - headwordIndices.length)}`;
+		return node;
+	}
+	_createTagData(name, category) {
+		return {
+			name,
+			category,
+			order: 0,
+			score: 0,
+			content: [],
+			dictionaries: [],
+			redundant: false
+		};
+	}
+	_createSearchTag(text) {
+		return this._createTag(this._createTagData(text, "search"));
+	}
+	_createGroupedPronunciation(details) {
+		const { dictionary, dictionaryAlias, pronunciations } = details;
+		const node = this._instantiate("pronunciation-group");
+		node.dataset.dictionary = dictionary;
+		node.dataset.pronunciationsMulti = "true";
+		node.dataset.pronunciationsCount = `${pronunciations.length}`;
+		const n1 = this._querySelector(node, ".pronunciation-group-tag-list");
+		const tag = this._createTag(this._createTagData(dictionaryAlias, "pronunciation-dictionary"));
+		tag.dataset.details = dictionary;
+		n1.appendChild(tag);
+		let hasTags = false;
+		for (const { pronunciation: { tags } } of pronunciations) if (tags.length > 0) {
+			hasTags = true;
+			break;
+		}
+		const n = this._querySelector(node, ".pronunciation-list");
+		n.dataset.hasTags = `${hasTags}`;
+		this._appendMultiple(n, this._createPronunciation.bind(this), pronunciations);
+		return node;
+	}
+	_createPronunciation(details) {
+		const { pronunciation } = details;
+		switch (pronunciation.type) {
+			case "pitch-accent": return this._createPronunciationPitchAccent(pronunciation, details);
+			case "phonetic-transcription": return this._createPronunciationPhoneticTranscription(pronunciation, details);
+		}
+	}
+	_createPronunciationPhoneticTranscription(pronunciation, details) {
+		const { ipa, tags } = pronunciation;
+		const { exclusiveTerms, exclusiveReadings } = details;
+		const node = this._instantiate("pronunciation");
+		node.dataset.pronunciationType = pronunciation.type;
+		node.dataset.tagCount = `${tags.length}`;
+		let n = this._querySelector(node, ".pronunciation-tag-list");
+		this._appendMultiple(n, this._createTag.bind(this), tags);
+		n = this._querySelector(node, ".pronunciation-disambiguation-list");
+		this._createPronunciationDisambiguations(n, exclusiveTerms, exclusiveReadings);
+		n = this._querySelector(node, ".pronunciation-text-container");
+		this._setTextContent(n, ipa);
+		return node;
+	}
+	_createPronunciationPitchAccent(pitchAccent, details) {
+		const { positions, nasalPositions, devoicePositions, tags } = pitchAccent;
+		const { reading, exclusiveTerms, exclusiveReadings } = details;
+		const morae = require_pronunciation_generator.getKanaMorae(reading);
+		const node = this._instantiate("pronunciation");
+		node.dataset.pitchAccentDownstepPosition = `${positions}`;
+		node.dataset.pronunciationType = pitchAccent.type;
+		if (nasalPositions.length > 0) node.dataset.nasalMoraPosition = nasalPositions.join(" ");
+		if (devoicePositions.length > 0) node.dataset.devoiceMoraPosition = devoicePositions.join(" ");
+		node.dataset.tagCount = `${tags.length}`;
+		let n = this._querySelector(node, ".pronunciation-tag-list");
+		this._appendMultiple(n, this._createTag.bind(this), tags);
+		n = this._querySelector(node, ".pronunciation-disambiguation-list");
+		this._createPronunciationDisambiguations(n, exclusiveTerms, exclusiveReadings);
+		n = this._querySelector(node, ".pronunciation-downstep-notation-container");
+		n.appendChild(this._pronunciationGenerator.createPronunciationDownstepPosition(positions));
+		n = this._querySelector(node, ".pronunciation-text-container");
+		n.lang = this._language;
+		n.appendChild(this._pronunciationGenerator.createPronunciationText(morae, positions, nasalPositions, devoicePositions));
+		n = this._querySelector(node, ".pronunciation-graph-container");
+		n.appendChild(this._pronunciationGenerator.createPronunciationGraph(morae, positions));
+		return node;
+	}
+	_createPronunciationDisambiguations(container, exclusiveTerms, exclusiveReadings) {
+		const templateName = "pronunciation-disambiguation";
+		for (const term of exclusiveTerms) {
+			const node = this._instantiate(templateName);
+			node.dataset.type = "term";
+			this._setTextContent(node, term, this._language);
+			container.appendChild(node);
+		}
+		for (const exclusiveReading of exclusiveReadings) {
+			const node = this._instantiate(templateName);
+			node.dataset.type = "reading";
+			this._setTextContent(node, exclusiveReading, this._language);
+			container.appendChild(node);
+		}
+		container.dataset.count = `${exclusiveTerms.length + exclusiveReadings.length}`;
+		container.dataset.termCount = `${exclusiveTerms.length}`;
+		container.dataset.readingCount = `${exclusiveReadings.length}`;
+	}
+	_createFrequencyGroup(details, kanji) {
+		const { dictionary, dictionaryAlias, frequencies, freqCount } = details;
+		const node = this._instantiate("frequency-group-item");
+		const body = this._querySelector(node, ".tag-body-content");
+		const tagLabel = this._querySelector(node, ".tag-label-content");
+		const tag = this._querySelector(node, ".tag");
+		this._setTextContent(tagLabel, dictionaryAlias);
+		const ii = frequencies.length;
+		for (let i = 0; i < ii; ++i) {
+			const item = frequencies[i];
+			const itemNode = kanji ? this._createKanjiFrequency(item, dictionary, dictionaryAlias, freqCount?.toString()) : this._createTermFrequency(item, dictionary, dictionaryAlias, freqCount?.toString());
+			itemNode.dataset.index = `${i}`;
+			body.appendChild(itemNode);
+		}
+		body.dataset.count = `${ii}`;
+		node.dataset.count = `${ii}`;
+		node.dataset.details = dictionary;
+		tag.dataset.details = `${dictionary}\nDictionary size: ${freqCount?.toString()}${kanji ? " kanji" : " terms"}`;
+		return node;
+	}
+	_createTermFrequency(details, dictionary, dictionaryAlias, freqCount) {
+		const { term, reading, values } = details;
+		const node = this._instantiate("term-frequency-item");
+		const tagLabel = this._querySelector(node, ".tag-label-content");
+		const tag = this._querySelector(node, ".tag");
+		const disambiguationTerm = this._querySelector(node, ".frequency-disambiguation-term");
+		const disambiguationReading = this._querySelector(node, ".frequency-disambiguation-reading");
+		const frequencyValueList = this._querySelector(node, ".frequency-value-list");
+		this._setTextContent(tagLabel, dictionaryAlias);
+		this._setTextContent(disambiguationTerm, term, this._language);
+		this._setTextContent(disambiguationReading, reading !== null ? reading : "", this._language);
+		this._populateFrequencyValueList(frequencyValueList, values);
+		node.dataset.term = term;
+		if (typeof reading === "string") node.dataset.reading = reading;
+		node.dataset.hasReading = `${reading !== null}`;
+		node.dataset.readingIsSame = `${reading === term}`;
+		node.dataset.dictionary = dictionary;
+		node.dataset.details = dictionary;
+		tag.dataset.details = `${dictionary}\nDictionary size: ${freqCount ?? ""} terms`;
+		return node;
+	}
+	_createKanjiFrequency(details, dictionary, dictionaryAlias, freqCount) {
+		const { character, values } = details;
+		const node = this._instantiate("kanji-frequency-item");
+		const tagLabel = this._querySelector(node, ".tag-label-content");
+		const tag = this._querySelector(node, ".tag");
+		const frequencyValueList = this._querySelector(node, ".frequency-value-list");
+		this._setTextContent(tagLabel, dictionaryAlias);
+		this._populateFrequencyValueList(frequencyValueList, values);
+		node.dataset.character = character;
+		node.dataset.dictionary = dictionary;
+		node.dataset.details = dictionary;
+		tag.dataset.details = `${dictionary}\nDictionary size: ${freqCount ?? ""} kanji`;
+		return node;
+	}
+	_populateFrequencyValueList(node, values) {
+		let fullFrequency = "";
+		for (let i = 0, ii = values.length; i < ii; ++i) {
+			const { frequency, displayValue } = values[i];
+			const frequencyString = `${frequency}`;
+			const text = displayValue !== null ? displayValue : `${frequency}`;
+			if (i > 0) {
+				const node2$1 = this._document.createElement("span");
+				node2$1.className = "frequency-value";
+				node2$1.dataset.frequency = `${frequency}`;
+				node2$1.textContent = ", ";
+				node.appendChild(node2$1);
+				fullFrequency += ", ";
+			}
+			const node2 = this._document.createElement("span");
+			node2.className = "frequency-value";
+			node2.dataset.frequency = frequencyString;
+			if (displayValue !== null) {
+				node2.dataset.displayValue = `${displayValue}`;
+				if (displayValue !== frequencyString) node2.title = frequencyString;
+			}
+			this._setTextContent(node2, text, this._language);
+			node.appendChild(node2);
+			fullFrequency += text;
+		}
+		node.dataset.frequency = fullFrequency;
+	}
+	_appendKanjiLinks(container, text) {
+		let part = "";
+		for (const c of text) if (require_pronunciation_generator.isCodePointKanji(c.codePointAt(0))) {
+			if (part.length > 0) {
+				container.appendChild(this._document.createTextNode(part));
+				part = "";
+			}
+			const link = this._createKanjiLink(c);
+			container.appendChild(link);
+		} else part += c;
+		if (part.length > 0) container.appendChild(this._document.createTextNode(part));
+	}
+	_appendMultiple(container, createItem, detailsArray, arg) {
+		let count = 0;
+		const ELEMENT_NODE = 1;
+		if (Array.isArray(detailsArray)) for (const details of detailsArray) {
+			const item = createItem(details, arg);
+			if (item === null) continue;
+			container.appendChild(item);
+			if (item.nodeType === ELEMENT_NODE) item.dataset.index = `${count}`;
+			++count;
+		}
+		container.dataset.count = `${count}`;
+		return count;
+	}
+	_appendFurigana(container, term, reading, addText) {
+		container.lang = this._language;
+		const segments = require_furigana.distributeFurigana(term, reading);
+		for (const { text, reading: furigana } of segments) if (furigana) {
+			const ruby = this._document.createElement("ruby");
+			const rt = this._document.createElement("rt");
+			addText(ruby, text);
+			ruby.appendChild(rt);
+			rt.appendChild(this._document.createTextNode(furigana));
+			container.appendChild(ruby);
+		} else addText(container, text);
+	}
+	_createDictionaryTag(dictionary) {
+		return this._createTagData(dictionary, "dictionary");
+	}
+	_setTextContent(node, value, language) {
+		this._setElementLanguage(node, language, value);
+		node.textContent = value;
+	}
+	_setMultilineTextContent(node, value, language) {
+		this._setElementLanguage(node, language, value);
+		let start = 0;
+		while (true) {
+			const end = value.indexOf("\n", start);
+			if (end < 0) break;
+			node.appendChild(this._document.createTextNode(value.substring(start, end)));
+			node.appendChild(this._document.createElement("br"));
+			start = end + 1;
+		}
+		if (start < value.length) node.appendChild(this._document.createTextNode(start === 0 ? value : value.substring(start)));
+	}
+	_setElementLanguage(element, language, content) {
+		if (typeof language === "string") element.lang = language;
+		else {
+			const language2 = require_text_utilities.getLanguageFromText(content, this._language);
+			if (language2 !== null) element.lang = language2;
+		}
+	}
+	_getPronunciationCategories(reading, termPronunciations, wordClasses, headwordIndex) {
+		if (termPronunciations.length === 0) return null;
+		const isVerbOrAdjective = require_dictionary_data_util.isNonNounVerbOrAdjective(wordClasses);
+		const categories = new Set();
+		for (const termPronunciation of termPronunciations) {
+			if (termPronunciation.headwordIndex !== headwordIndex) continue;
+			for (const pronunciation of termPronunciation.pronunciations) {
+				if (pronunciation.type !== "pitch-accent") continue;
+				const category = require_pronunciation_generator.getPitchCategory(reading, pronunciation.positions, isVerbOrAdjective);
+				if (category !== null) categories.add(category);
+			}
+		}
+		return categories.size > 0 ? [...categories].join(" ") : null;
+	}
+	_instantiate(name) {
+		return this._templates.instantiate(name);
+	}
+	_querySelector(element, selector) {
+		const result = element.querySelector(selector);
+		if (result === null) throw new Error(`Failed to find element: ${selector}`);
+		return result;
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'DisplayGenerator', {
+  enumerable: true,
+  get: function () {
+    return DisplayGenerator;
+  }
+});
+Object.defineProperty(exports, 'HtmlTemplateCollection', {
+  enumerable: true,
+  get: function () {
+    return HtmlTemplateCollection;
+  }
+});
+//# sourceMappingURL=display-generator-DyP-HNzP.cjs.map