Merge branch 'master' of https://github.com/FooSoft/yomichan

24 files changed, 586 insertions, 387 deletions

diff --git a/ext/bg/data/options-schema.json b/ext/bg/data/options-schema.json
index da1f1ce0..4f9e694d 100644
--- a/ext/bg/data/options-schema.json
+++ b/ext/bg/data/options-schema.json
@@ -388,7 +388,8 @@
                                     "convertNumericCharacters",
                                     "convertAlphabeticCharacters",
                                     "convertHiraganaToKatakana",
-                                    "convertKatakanaToHiragana"
+                                    "convertKatakanaToHiragana",
+                                    "collapseEmphaticSequences"
                                 ],
                                 "properties": {
                                     "convertHalfWidthCharacters": {
@@ -415,6 +416,11 @@
                                         "type": "string",
                                         "enum": ["false", "true", "variant"],
                                         "default": "variant"
+                                    },
+                                    "collapseEmphaticSequences": {
+                                        "type": "string",
+                                        "enum": ["false", "true", "full"],
+                                        "default": "false"
                                     }
                                 }
                             },
diff --git a/ext/bg/js/backend.js b/ext/bg/js/backend.js
index 6386319b..2265c1a9 100644
--- a/ext/bg/js/backend.js
+++ b/ext/bg/js/backend.js
@@ -30,7 +30,6 @@
  * Translator
  * conditionsTestValue
  * dictConfigured
- * dictEnabledSet
  * dictTermsSort
  * handlebarsRenderDynamic
  * jp
@@ -76,33 +75,32 @@ class Backend {
         this.messageToken = yomichan.generateId(16);
 
         this._messageHandlers = new Map([
-            ['yomichanCoreReady', this._onApiYomichanCoreReady.bind(this)],
-            ['optionsSchemaGet', this._onApiOptionsSchemaGet.bind(this)],
-            ['optionsGet', this._onApiOptionsGet.bind(this)],
-            ['optionsGetFull', this._onApiOptionsGetFull.bind(this)],
-            ['optionsSet', this._onApiOptionsSet.bind(this)],
-            ['optionsSave', this._onApiOptionsSave.bind(this)],
-            ['kanjiFind', this._onApiKanjiFind.bind(this)],
-            ['termsFind', this._onApiTermsFind.bind(this)],
-            ['textParse', this._onApiTextParse.bind(this)],
-            ['textParseMecab', this._onApiTextParseMecab.bind(this)],
-            ['definitionAdd', this._onApiDefinitionAdd.bind(this)],
-            ['definitionsAddable', this._onApiDefinitionsAddable.bind(this)],
-            ['noteView', this._onApiNoteView.bind(this)],
-            ['templateRender', this._onApiTemplateRender.bind(this)],
-            ['commandExec', this._onApiCommandExec.bind(this)],
-            ['audioGetUri', this._onApiAudioGetUri.bind(this)],
-            ['screenshotGet', this._onApiScreenshotGet.bind(this)],
-            ['forward', this._onApiForward.bind(this)],
-            ['frameInformationGet', this._onApiFrameInformationGet.bind(this)],
-            ['injectStylesheet', this._onApiInjectStylesheet.bind(this)],
-            ['getEnvironmentInfo', this._onApiGetEnvironmentInfo.bind(this)],
-            ['clipboardGet', this._onApiClipboardGet.bind(this)],
-            ['getDisplayTemplatesHtml', this._onApiGetDisplayTemplatesHtml.bind(this)],
-            ['getQueryParserTemplatesHtml', this._onApiGetQueryParserTemplatesHtml.bind(this)],
-            ['getZoom', this._onApiGetZoom.bind(this)],
-            ['getMessageToken', this._onApiGetMessageToken.bind(this)],
-            ['getDefaultAnkiFieldTemplates', this._onApiGetDefaultAnkiFieldTemplates.bind(this)]
+            ['yomichanCoreReady', {handler: this._onApiYomichanCoreReady.bind(this), async: false}],
+            ['optionsSchemaGet', {handler: this._onApiOptionsSchemaGet.bind(this), async: false}],
+            ['optionsGet', {handler: this._onApiOptionsGet.bind(this), async: false}],
+            ['optionsGetFull', {handler: this._onApiOptionsGetFull.bind(this), async: false}],
+            ['optionsSet', {handler: this._onApiOptionsSet.bind(this), async: true}],
+            ['optionsSave', {handler: this._onApiOptionsSave.bind(this), async: true}],
+            ['kanjiFind', {handler: this._onApiKanjiFind.bind(this), async: true}],
+            ['termsFind', {handler: this._onApiTermsFind.bind(this), async: true}],
+            ['textParse', {handler: this._onApiTextParse.bind(this), async: true}],
+            ['definitionAdd', {handler: this._onApiDefinitionAdd.bind(this), async: true}],
+            ['definitionsAddable', {handler: this._onApiDefinitionsAddable.bind(this), async: true}],
+            ['noteView', {handler: this._onApiNoteView.bind(this), async: true}],
+            ['templateRender', {handler: this._onApiTemplateRender.bind(this), async: true}],
+            ['commandExec', {handler: this._onApiCommandExec.bind(this), async: false}],
+            ['audioGetUri', {handler: this._onApiAudioGetUri.bind(this), async: true}],
+            ['screenshotGet', {handler: this._onApiScreenshotGet.bind(this), async: true}],
+            ['broadcastTab', {handler: this._onApiBroadcastTab.bind(this), async: false}],
+            ['frameInformationGet', {handler: this._onApiFrameInformationGet.bind(this), async: true}],
+            ['injectStylesheet', {handler: this._onApiInjectStylesheet.bind(this), async: true}],
+            ['getEnvironmentInfo', {handler: this._onApiGetEnvironmentInfo.bind(this), async: true}],
+            ['clipboardGet', {handler: this._onApiClipboardGet.bind(this), async: true}],
+            ['getDisplayTemplatesHtml', {handler: this._onApiGetDisplayTemplatesHtml.bind(this), async: true}],
+            ['getQueryParserTemplatesHtml', {handler: this._onApiGetQueryParserTemplatesHtml.bind(this), async: true}],
+            ['getZoom', {handler: this._onApiGetZoom.bind(this), async: true}],
+            ['getMessageToken', {handler: this._onApiGetMessageToken.bind(this), async: false}],
+            ['getDefaultAnkiFieldTemplates', {handler: this._onApiGetDefaultAnkiFieldTemplates.bind(this), async: false}]
         ]);
 
         this._commandHandlers = new Map([
@@ -166,16 +164,23 @@ class Backend {
     }
 
     onMessage({action, params}, sender, callback) {
-        const handler = this._messageHandlers.get(action);
-        if (typeof handler !== 'function') { return false; }
+        const messageHandler = this._messageHandlers.get(action);
+        if (typeof messageHandler === 'undefined') { return false; }
+
+        const {handler, async} = messageHandler;
 
         try {
-            const promise = handler(params, sender);
-            promise.then(
-                (result) => callback({result}),
-                (error) => callback({error: errorToJson(error)})
-            );
-            return true;
+            const promiseOrResult = handler(params, sender);
+            if (async) {
+                promiseOrResult.then(
+                    (result) => callback({result}),
+                    (error) => callback({error: errorToJson(error)})
+                );
+                return true;
+            } else {
+                callback({result: promiseOrResult});
+                return false;
+            }
         } catch (error) {
             callback({error: errorToJson(error)});
             return false;
@@ -308,31 +313,84 @@ class Backend {
         return await this.dictionaryImporter.import(this.database, archiveSource, onProgress, details);
     }
 
+    async _textParseScanning(text, options) {
+        const results = [];
+        while (text.length > 0) {
+            const term = [];
+            const [definitions, sourceLength] = await this.translator.findTerms(
+                'simple',
+                text.substring(0, options.scanning.length),
+                {},
+                options
+            );
+            if (definitions.length > 0 && sourceLength > 0) {
+                dictTermsSort(definitions);
+                const {expression, reading} = definitions[0];
+                const source = text.substring(0, sourceLength);
+                for (const {text: text2, furigana} of jp.distributeFuriganaInflected(expression, reading, source)) {
+                    const reading2 = jp.convertReading(text2, furigana, options.parsing.readingMode);
+                    term.push({text: text2, reading: reading2});
+                }
+                text = text.substring(source.length);
+            } else {
+                const reading = jp.convertReading(text[0], '', options.parsing.readingMode);
+                term.push({text: text[0], reading});
+                text = text.substring(1);
+            }
+            results.push(term);
+        }
+        return results;
+    }
+
+    async _textParseMecab(text, options) {
+        const results = [];
+        const rawResults = await this.mecab.parseText(text);
+        for (const [mecabName, parsedLines] of Object.entries(rawResults)) {
+            const result = [];
+            for (const parsedLine of parsedLines) {
+                for (const {expression, reading, source} of parsedLine) {
+                    const term = [];
+                    for (const {text: text2, furigana} of jp.distributeFuriganaInflected(
+                        expression.length > 0 ? expression : source,
+                        jp.convertKatakanaToHiragana(reading),
+                        source
+                    )) {
+                        const reading2 = jp.convertReading(text2, furigana, options.parsing.readingMode);
+                        term.push({text: text2, reading: reading2});
+                    }
+                    result.push(term);
+                }
+                result.push([{text: '\n', reading: ''}]);
+            }
+            results.push([mecabName, result]);
+        }
+        return results;
+    }
+
     // Message handlers
 
     _onApiYomichanCoreReady(_params, sender) {
         // tab ID isn't set in background (e.g. browser_action)
+        const callback = () => this.checkLastError(chrome.runtime.lastError);
+        const data = {action: 'backendPrepared'};
         if (typeof sender.tab === 'undefined') {
-            const callback = () => this.checkLastError(chrome.runtime.lastError);
-            chrome.runtime.sendMessage({action: 'backendPrepared'}, callback);
-            return Promise.resolve();
+            chrome.runtime.sendMessage(data, callback);
+            return false;
+        } else {
+            chrome.tabs.sendMessage(sender.tab.id, data, callback);
+            return true;
         }
-
-        const tabId = sender.tab.id;
-        return new Promise((resolve) => {
-            chrome.tabs.sendMessage(tabId, {action: 'backendPrepared'}, resolve);
-        });
     }
 
-    async _onApiOptionsSchemaGet() {
+    _onApiOptionsSchemaGet() {
         return this.getOptionsSchema();
     }
 
-    async _onApiOptionsGet({optionsContext}) {
+    _onApiOptionsGet({optionsContext}) {
         return this.getOptions(optionsContext);
     }
 
-    async _onApiOptionsGetFull() {
+    _onApiOptionsGetFull() {
         return this.getFullOptions();
     }
 
@@ -400,61 +458,27 @@ class Backend {
     async _onApiTextParse({text, optionsContext}) {
         const options = this.getOptions(optionsContext);
         const results = [];
-        while (text.length > 0) {
-            const term = [];
-            const [definitions, sourceLength] = await this.translator.findTerms(
-                'simple',
-                text.substring(0, options.scanning.length),
-                {},
-                options
-            );
-            if (definitions.length > 0) {
-                dictTermsSort(definitions);
-                const {expression, reading} = definitions[0];
-                const source = text.substring(0, sourceLength);
-                for (const {text: text2, furigana} of jp.distributeFuriganaInflected(expression, reading, source)) {
-                    const reading2 = jp.convertReading(text2, furigana, options.parsing.readingMode);
-                    term.push({text: text2, reading: reading2});
-                }
-                text = text.substring(source.length);
-            } else {
-                const reading = jp.convertReading(text[0], null, options.parsing.readingMode);
-                term.push({text: text[0], reading});
-                text = text.substring(1);
-            }
-            results.push(term);
+
+        if (options.parsing.enableScanningParser) {
+            results.push({
+                source: 'scanning-parser',
+                id: 'scan',
+                content: await this._textParseScanning(text, options)
+            });
         }
-        return results;
-    }
 
-    async _onApiTextParseMecab({text, optionsContext}) {
-        const options = this.getOptions(optionsContext);
-        const results = [];
-        const rawResults = await this.mecab.parseText(text);
-        for (const [mecabName, parsedLines] of Object.entries(rawResults)) {
-            const result = [];
-            for (const parsedLine of parsedLines) {
-                for (const {expression, reading, source} of parsedLine) {
-                    const term = [];
-                    if (expression !== null && reading !== null) {
-                        for (const {text: text2, furigana} of jp.distributeFuriganaInflected(
-                            expression,
-                            jp.convertKatakanaToHiragana(reading),
-                            source
-                        )) {
-                            const reading2 = jp.convertReading(text2, furigana, options.parsing.readingMode);
-                            term.push({text: text2, reading: reading2});
-                        }
-                    } else {
-                        const reading2 = jp.convertReading(source, null, options.parsing.readingMode);
-                        term.push({text: source, reading: reading2});
-                    }
-                    result.push(term);
-                }
-                result.push([{text: '\n'}]);
+        if (options.parsing.enableMecabParser) {
+            const mecabResults = await this._textParseMecab(text, options);
+            for (const [mecabDictName, mecabDictResults] of mecabResults) {
+                results.push({
+                    source: 'mecab',
+                    dictionary: mecabDictName,
+                    id: `mecab-${mecabDictName}`,
+                    content: mecabDictResults
+                });
             }
-            results.push([mecabName, result]);
         }
+
         return results;
     }
 
@@ -539,7 +563,7 @@ class Backend {
         return this._renderTemplate(template, data);
     }
 
-    async _onApiCommandExec({command, params}) {
+    _onApiCommandExec({command, params}) {
         return this._runCommand(command, params);
     }
 
@@ -559,15 +583,15 @@ class Backend {
         });
     }
 
-    _onApiForward({action, params}, sender) {
+    _onApiBroadcastTab({action, params}, sender) {
         if (!(sender && sender.tab)) {
-            return Promise.resolve();
+            return false;
         }
 
         const tabId = sender.tab.id;
-        return new Promise((resolve) => {
-            chrome.tabs.sendMessage(tabId, {action, params}, (response) => resolve(response));
-        });
+        const callback = () => this.checkLastError(chrome.runtime.lastError);
+        chrome.tabs.sendMessage(tabId, {action, params}, callback);
+        return true;
     }
 
     _onApiFrameInformationGet(params, sender) {
@@ -690,11 +714,11 @@ class Backend {
         });
     }
 
-    async _onApiGetMessageToken() {
+    _onApiGetMessageToken() {
         return this.messageToken;
     }
 
-    async _onApiGetDefaultAnkiFieldTemplates() {
+    _onApiGetDefaultAnkiFieldTemplates() {
         return this.defaultAnkiFieldTemplates;
     }
 
diff --git a/ext/bg/js/database.js b/ext/bg/js/database.js
index ad4e3bad..260c815a 100644
--- a/ext/bg/js/database.js
+++ b/ext/bg/js/database.js
@@ -16,10 +16,7 @@
  */
 
 /* global
- * JSZip
- * JsonSchema
  * dictFieldSplit
- * requestJson
  */
 
 class Database {
diff --git a/ext/bg/js/japanese.js b/ext/bg/js/japanese.js
index 5c49cca7..ac81acb5 100644
--- a/ext/bg/js/japanese.js
+++ b/ext/bg/js/japanese.js
@@ -82,6 +82,9 @@
 
     const ITERATION_MARK_CODE_POINT = 0x3005;
 
+    const HIRAGANA_SMALL_TSU_CODE_POINT = 0x3063;
+    const KATAKANA_SMALL_TSU_CODE_POINT = 0x30c3;
+    const KANA_PROLONGED_SOUND_MARK_CODE_POINT = 0x30fc;
 
     // Existing functions
 
@@ -121,25 +124,25 @@
         return wanakana.toRomaji(text);
     }
 
-    function convertReading(expressionFragment, readingFragment, readingMode) {
+    function convertReading(expression, reading, readingMode) {
         switch (readingMode) {
             case 'hiragana':
-                return convertKatakanaToHiragana(readingFragment || '');
+                return convertKatakanaToHiragana(reading);
             case 'katakana':
-                return convertHiraganaToKatakana(readingFragment || '');
+                return convertHiraganaToKatakana(reading);
             case 'romaji':
-                if (readingFragment) {
-                    return convertToRomaji(readingFragment);
+                if (reading) {
+                    return convertToRomaji(reading);
                 } else {
-                    if (isStringEntirelyKana(expressionFragment)) {
-                        return convertToRomaji(expressionFragment);
+                    if (isStringEntirelyKana(expression)) {
+                        return convertToRomaji(expression);
                     }
                 }
-                return readingFragment;
+                return reading;
             case 'none':
-                return null;
+                return '';
             default:
-                return readingFragment;
+                return reading;
         }
     }
 
@@ -297,7 +300,7 @@
                     const readingLeft = reading2.substring(group.text.length);
                     const segs = segmentize(readingLeft, groups.splice(1));
                     if (segs) {
-                        return [{text: group.text}].concat(segs);
+                        return [{text: group.text, furigana: ''}].concat(segs);
                     }
                 }
             } else {
@@ -365,13 +368,47 @@
         }
 
         if (stemLength !== source.length) {
-            output.push({text: source.substring(stemLength)});
+            output.push({text: source.substring(stemLength), furigana: ''});
         }
 
         return output;
     }
 
 
+    // Miscellaneous
+
+    function collapseEmphaticSequences(text, fullCollapse, sourceMap=null) {
+        let result = '';
+        let collapseCodePoint = -1;
+        const hasSourceMap = (sourceMap !== null);
+        for (const char of text) {
+            const c = char.codePointAt(0);
+            if (
+                c === HIRAGANA_SMALL_TSU_CODE_POINT ||
+                c === KATAKANA_SMALL_TSU_CODE_POINT ||
+                c === KANA_PROLONGED_SOUND_MARK_CODE_POINT
+            ) {
+                if (collapseCodePoint !== c) {
+                    collapseCodePoint = c;
+                    if (!fullCollapse) {
+                        result += char;
+                        continue;
+                    }
+                }
+            } else {
+                collapseCodePoint = -1;
+                result += char;
+                continue;
+            }
+
+            if (hasSourceMap) {
+                sourceMap.combine(Math.max(0, result.length - 1), 1);
+            }
+        }
+        return result;
+    }
+
+
     // Exports
 
     Object.assign(jp, {
@@ -383,6 +420,7 @@
         convertHalfWidthKanaToFullWidth,
         convertAlphabeticToKana,
         distributeFurigana,
-        distributeFuriganaInflected
+        distributeFuriganaInflected,
+        collapseEmphaticSequences
     });
 })();
diff --git a/ext/bg/js/mecab.js b/ext/bg/js/mecab.js
index cd6e6c57..597dceae 100644
--- a/ext/bg/js/mecab.js
+++ b/ext/bg/js/mecab.js
@@ -40,7 +40,36 @@ class Mecab {
     }
 
     async parseText(text) {
-        return await this.invoke('parse_text', {text});
+        const rawResults = await this.invoke('parse_text', {text});
+        // {
+        //     'mecab-name': [
+        //         // line1
+        //         [
+        //             {str expression: 'expression', str reading: 'reading', str source: 'source'},
+        //             {str expression: 'expression2', str reading: 'reading2', str source: 'source2'}
+        //         ],
+        //         line2,
+        //         ...
+        //     ],
+        //     'mecab-name2': [...]
+        // }
+        const results = {};
+        for (const [mecabName, parsedLines] of Object.entries(rawResults)) {
+            const result = [];
+            for (const parsedLine of parsedLines) {
+                const line = [];
+                for (const {expression, reading, source} of parsedLine) {
+                    line.push({
+                        expression: expression || '',
+                        reading: reading || '',
+                        source: source || ''
+                    });
+                }
+                result.push(line);
+            }
+            results[mecabName] = result;
+        }
+        return results;
     }
 
     startListener() {
diff --git a/ext/bg/js/options.js b/ext/bg/js/options.js
index 20df2a68..f3e5f60d 100644
--- a/ext/bg/js/options.js
+++ b/ext/bg/js/options.js
@@ -170,7 +170,8 @@ function profileOptionsCreateDefaults() {
             convertNumericCharacters: 'false',
             convertAlphabeticCharacters: 'false',
             convertHiraganaToKatakana: 'false',
-            convertKatakanaToHiragana: 'variant'
+            convertKatakanaToHiragana: 'variant',
+            collapseEmphaticSequences: 'false'
         },
 
         dictionaries: {},
diff --git a/ext/bg/js/search-frontend.js b/ext/bg/js/search-frontend.js
index 9cc1436f..e534e771 100644
--- a/ext/bg/js/search-frontend.js
+++ b/ext/bg/js/search-frontend.js
@@ -19,18 +19,7 @@
  * apiOptionsGet
  */
 
-async function searchFrontendSetup() {
-    await yomichan.prepare();
-
-    const optionsContext = {
-        depth: 0,
-        url: window.location.href
-    };
-    const options = await apiOptionsGet(optionsContext);
-    if (!options.scanning.enableOnSearchPage) { return; }
-
-    window.frontendInitializationData = {depth: 1, proxy: false};
-
+function injectSearchFrontend() {
     const scriptSrcs = [
         '/mixed/js/text-scanner.js',
         '/fg/js/frontend-api-receiver.js',
@@ -62,4 +51,29 @@ async function searchFrontendSetup() {
     }
 }
 
-searchFrontendSetup();
+async function main() {
+    await yomichan.prepare();
+
+    let optionsApplied = false;
+
+    const applyOptions = async () => {
+        const optionsContext = {
+            depth: 0,
+            url: window.location.href
+        };
+        const options = await apiOptionsGet(optionsContext);
+        if (!options.scanning.enableOnSearchPage || optionsApplied) { return; }
+        optionsApplied = true;
+
+        window.frontendInitializationData = {depth: 1, proxy: false, isSearchPage: true};
+        injectSearchFrontend();
+
+        yomichan.off('optionsUpdated', applyOptions);
+    };
+
+    yomichan.on('optionsUpdated', applyOptions);
+
+    await applyOptions();
+}
+
+main();
diff --git a/ext/bg/js/search-query-parser-generator.js b/ext/bg/js/search-query-parser-generator.js
index 390841c1..9e7ff8aa 100644
--- a/ext/bg/js/search-query-parser-generator.js
+++ b/ext/bg/js/search-query-parser-generator.js
@@ -36,7 +36,7 @@ class QueryParserGenerator {
             const termContainer = this._templateHandler.instantiate(preview ? 'term-preview' : 'term');
             for (const segment of term) {
                 if (!segment.text.trim()) { continue; }
-                if (!segment.reading || !segment.reading.trim()) {
+                if (!segment.reading.trim()) {
                     termContainer.appendChild(this.createSegmentText(segment.text));
                 } else {
                     termContainer.appendChild(this.createSegment(segment));
@@ -71,7 +71,17 @@ class QueryParserGenerator {
         for (const parseResult of parseResults) {
             const optionContainer = this._templateHandler.instantiate('select-option');
             optionContainer.value = parseResult.id;
-            optionContainer.textContent = parseResult.name;
+            switch (parseResult.source) {
+                case 'scanning-parser':
+                    optionContainer.textContent = 'Scanning parser';
+                    break;
+                case 'mecab':
+                    optionContainer.textContent = `MeCab: ${parseResult.dictionary}`;
+                    break;
+                default:
+                    optionContainer.textContent = 'Unrecognized dictionary';
+                    break;
+            }
             optionContainer.defaultSelected = selectedParser === parseResult.id;
             selectContainer.appendChild(optionContainer);
         }
diff --git a/ext/bg/js/search-query-parser.js b/ext/bg/js/search-query-parser.js
index 01a0ace5..eb3b681c 100644
--- a/ext/bg/js/search-query-parser.js
+++ b/ext/bg/js/search-query-parser.js
@@ -21,13 +21,12 @@
  * apiOptionsSet
  * apiTermsFind
  * apiTextParse
- * apiTextParseMecab
  * docSentenceExtract
  */
 
 class QueryParser extends TextScanner {
     constructor({getOptionsContext, setContent, setSpinnerVisible}) {
-        super(document.querySelector('#query-parser-content'), [], []);
+        super(document.querySelector('#query-parser-content'), () => [], []);
 
         this.getOptionsContext = getOptionsContext;
         this.setContent = setContent;
@@ -128,7 +127,7 @@ class QueryParser extends TextScanner {
 
         this.setPreview(text);
 
-        this.parseResults = await this.parseText(text);
+        this.parseResults = await apiTextParse(text, this.getOptionsContext());
         this.refreshSelectedParser();
 
         this.renderParserSelect();
@@ -137,33 +136,11 @@ class QueryParser extends TextScanner {
         this.setSpinnerVisible(false);
     }
 
-    async parseText(text) {
-        const results = [];
-        if (this.options.parsing.enableScanningParser) {
-            results.push({
-                name: 'Scanning parser',
-                id: 'scan',
-                parsedText: await apiTextParse(text, this.getOptionsContext())
-            });
-        }
-        if (this.options.parsing.enableMecabParser) {
-            const mecabResults = await apiTextParseMecab(text, this.getOptionsContext());
-            for (const [mecabDictName, mecabDictResults] of mecabResults) {
-                results.push({
-                    name: `MeCab: ${mecabDictName}`,
-                    id: `mecab-${mecabDictName}`,
-                    parsedText: mecabDictResults
-                });
-            }
-        }
-        return results;
-    }
-
     setPreview(text) {
         const previewTerms = [];
         for (let i = 0, ii = text.length; i < ii; i += 2) {
             const tempText = text.substring(i, i + 2);
-            previewTerms.push([{text: tempText}]);
+            previewTerms.push([{text: tempText, reading: ''}]);
         }
         this.queryParser.textContent = '';
         this.queryParser.appendChild(this.queryParserGenerator.createParseResult(previewTerms, true));
@@ -183,6 +160,6 @@ class QueryParser extends TextScanner {
         const parseResult = this.getParseResult();
         this.queryParser.textContent = '';
         if (!parseResult) { return; }
-        this.queryParser.appendChild(this.queryParserGenerator.createParseResult(parseResult.parsedText));
+        this.queryParser.appendChild(this.queryParserGenerator.createParseResult(parseResult.content));
     }
 }
diff --git a/ext/bg/js/search.js b/ext/bg/js/search.js
index 2ba3e468..871c576b 100644
--- a/ext/bg/js/search.js
+++ b/ext/bg/js/search.js
@@ -208,7 +208,7 @@ class DisplaySearch extends Display {
 
     onCopy() {
         // ignore copy from search page
-        this.clipboardMonitor.setPreviousText(document.getSelection().toString().trim());
+        this.clipboardMonitor.setPreviousText(window.getSelection().toString().trim());
     }
 
     onExternalSearchUpdate({text}) {
diff --git a/ext/bg/js/settings/main.js b/ext/bg/js/settings/main.js
index 8fd94562..308e92eb 100644
--- a/ext/bg/js/settings/main.js
+++ b/ext/bg/js/settings/main.js
@@ -118,6 +118,7 @@ async function formRead(options) {
     options.translation.convertAlphabeticCharacters = $('#translation-convert-alphabetic-characters').val();
     options.translation.convertHiraganaToKatakana = $('#translation-convert-hiragana-to-katakana').val();
     options.translation.convertKatakanaToHiragana = $('#translation-convert-katakana-to-hiragana').val();
+    options.translation.collapseEmphaticSequences = $('#translation-collapse-emphatic-sequences').val();
 
     options.parsing.enableScanningParser = $('#parsing-scan-enable').prop('checked');
     options.parsing.enableMecabParser = $('#parsing-mecab-enable').prop('checked');
@@ -199,6 +200,7 @@ async function formWrite(options) {
     $('#translation-convert-alphabetic-characters').val(options.translation.convertAlphabeticCharacters);
     $('#translation-convert-hiragana-to-katakana').val(options.translation.convertHiraganaToKatakana);
     $('#translation-convert-katakana-to-hiragana').val(options.translation.convertKatakanaToHiragana);
+    $('#translation-collapse-emphatic-sequences').val(options.translation.collapseEmphaticSequences);
 
     $('#parsing-scan-enable').prop('checked', options.parsing.enableScanningParser);
     $('#parsing-mecab-enable').prop('checked', options.parsing.enableMecabParser);
diff --git a/ext/bg/js/translator.js b/ext/bg/js/translator.js
index e4441384..aaa1a0ec 100644
--- a/ext/bg/js/translator.js
+++ b/ext/bg/js/translator.js
@@ -347,17 +347,27 @@ class Translator {
 
     getAllDeinflections(text, options) {
         const translationOptions = options.translation;
+        const collapseEmphaticOptions = [[false, false]];
+        switch (translationOptions.collapseEmphaticSequences) {
+            case 'true':
+                collapseEmphaticOptions.push([true, false]);
+                break;
+            case 'full':
+                collapseEmphaticOptions.push([true, false], [true, true]);
+                break;
+        }
         const textOptionVariantArray = [
             Translator.getTextOptionEntryVariants(translationOptions.convertHalfWidthCharacters),
             Translator.getTextOptionEntryVariants(translationOptions.convertNumericCharacters),
             Translator.getTextOptionEntryVariants(translationOptions.convertAlphabeticCharacters),
             Translator.getTextOptionEntryVariants(translationOptions.convertHiraganaToKatakana),
-            Translator.getTextOptionEntryVariants(translationOptions.convertKatakanaToHiragana)
+            Translator.getTextOptionEntryVariants(translationOptions.convertKatakanaToHiragana),
+            collapseEmphaticOptions
         ];
 
         const deinflections = [];
         const used = new Set();
-        for (const [halfWidth, numeric, alphabetic, katakana, hiragana] of Translator.getArrayVariants(textOptionVariantArray)) {
+        for (const [halfWidth, numeric, alphabetic, katakana, hiragana, [collapseEmphatic, collapseEmphaticFull]] of Translator.getArrayVariants(textOptionVariantArray)) {
             let text2 = text;
             const sourceMap = new TextSourceMap(text2);
             if (halfWidth) {
@@ -375,6 +385,9 @@ class Translator {
             if (hiragana) {
                 text2 = jp.convertKatakanaToHiragana(text2);
             }
+            if (collapseEmphatic) {
+                text2 = jp.collapseEmphaticSequences(text2, collapseEmphaticFull, sourceMap);
+            }
 
             for (let i = text2.length; i > 0; --i) {
                 const text2Substring = text2.substring(0, i);
diff --git a/ext/bg/settings.html b/ext/bg/settings.html
index 1297a9cc..96c1db82 100644
--- a/ext/bg/settings.html
+++ b/ext/bg/settings.html
@@ -427,7 +427,7 @@
 
                 <p class="help-block">
                     The conversion options below are listed in the order that the conversions are applied to the input text.
-                    Each conversion has three possible values:
+                    Conversions commonly have three possible values:
                 </p>
 
                 <ul class="help-block">
@@ -490,6 +490,15 @@
                         <option value="variant">Use both variants</option>
                     </select>
                 </div>
+
+                <div class="form-group">
+                    <label for="translation-collapse-emphatic-sequences">Collapse emphatic character sequences <span class="label-light">(すっっごーーい &rarr; すっごーい / すごい)</span></label>
+                    <select class="form-control" id="translation-collapse-emphatic-sequences">
+                        <option value="false">Disabled</option>
+                        <option value="true">Collapse into single character</option>
+                        <option value="full">Remove all characters</option>
+                    </select>
+                </div>
             </div>
 
             <div id="popup-content-scanning">
diff --git a/ext/fg/js/float.js b/ext/fg/js/float.js
index 77e5ea0a..5c2c50c2 100644
--- a/ext/fg/js/float.js
+++ b/ext/fg/js/float.js
@@ -17,7 +17,7 @@
 
 /* global
  * Display
- * apiForward
+ * apiBroadcastTab
  * apiGetMessageToken
  * popupNestedInitialize
  */
@@ -79,7 +79,7 @@ class DisplayFloat extends Display {
 
         this.setContentScale(scale);
 
-        apiForward('popupPrepareCompleted', {targetPopupId: this._popupId});
+        apiBroadcastTab('popupPrepareCompleted', {targetPopupId: this._popupId});
     }
 
     onError(error) {
@@ -180,7 +180,7 @@ class DisplayFloat extends Display {
                 },
                 2000
             );
-            apiForward('requestDocumentInformationBroadcast', {uniqueId});
+            apiBroadcastTab('requestDocumentInformationBroadcast', {uniqueId});
 
             const {title} = await promise;
             return title;
diff --git a/ext/fg/js/frame-offset-forwarder.js b/ext/fg/js/frame-offset-forwarder.js
index b3c10bb8..c658c55a 100644
--- a/ext/fg/js/frame-offset-forwarder.js
+++ b/ext/fg/js/frame-offset-forwarder.js
@@ -16,7 +16,7 @@
  */
 
 /* global
- * apiForward
+ * apiBroadcastTab
  */
 
 class FrameOffsetForwarder {
@@ -96,6 +96,6 @@ class FrameOffsetForwarder {
     }
 
     _forwardFrameOffsetOrigin(offset, uniqueId) {
-        apiForward('frameOffset', {offset, uniqueId});
+        apiBroadcastTab('frameOffset', {offset, uniqueId});
     }
 }
diff --git a/ext/fg/js/frontend-initialize.js b/ext/fg/js/frontend-initialize.js
index 0a586ff9..2b942258 100644
--- a/ext/fg/js/frontend-initialize.js
+++ b/ext/fg/js/frontend-initialize.js
@@ -20,53 +20,105 @@
  * Frontend
  * PopupProxy
  * PopupProxyHost
- * apiForward
+ * apiBroadcastTab
  * apiOptionsGet
  */
 
+async function createIframePopupProxy(url, frameOffsetForwarder) {
+    const rootPopupInformationPromise = yomichan.getTemporaryListenerResult(
+        chrome.runtime.onMessage,
+        ({action, params}, {resolve}) => {
+            if (action === 'rootPopupInformation') {
+                resolve(params);
+            }
+        }
+    );
+    apiBroadcastTab('rootPopupRequestInformationBroadcast');
+    const {popupId, frameId} = await rootPopupInformationPromise;
+
+    const getFrameOffset = frameOffsetForwarder.getOffset.bind(frameOffsetForwarder);
+
+    const popup = new PopupProxy(popupId, 0, null, frameId, url, getFrameOffset);
+    await popup.prepare();
+
+    return popup;
+}
+
+async function getOrCreatePopup(depth) {
+    const popupHost = new PopupProxyHost();
+    await popupHost.prepare();
+
+    const popup = popupHost.getOrCreatePopup(null, null, depth);
+
+    return popup;
+}
+
+async function createPopupProxy(depth, id, parentFrameId, url) {
+    const popup = new PopupProxy(null, depth + 1, id, parentFrameId, url);
+    await popup.prepare();
+
+    return popup;
+}
+
 async function main() {
     await yomichan.prepare();
 
     const data = window.frontendInitializationData || {};
-    const {id, depth=0, parentFrameId, url, proxy=false} = data;
-
-    const optionsContext = {depth, url};
-    const options = await apiOptionsGet(optionsContext);
-
-    let popup;
-    if (!proxy && (window !== window.parent) && options.general.showIframePopupsInRootFrame) {
-        const rootPopupInformationPromise = yomichan.getTemporaryListenerResult(
-            chrome.runtime.onMessage,
-            ({action, params}, {resolve}) => {
-                if (action === 'rootPopupInformation') {
-                    resolve(params);
-                }
+    const {id, depth=0, parentFrameId, url=window.location.href, proxy=false, isSearchPage=false} = data;
+
+    const isIframe = !proxy && (window !== window.parent);
+
+    const popups = {
+        iframe: null,
+        proxy: null,
+        normal: null
+    };
+
+    let frontend = null;
+    let frontendPreparePromise = null;
+    let frameOffsetForwarder = null;
+
+    const applyOptions = async () => {
+        const optionsContext = {depth: isSearchPage ? 0 : depth, url};
+        const options = await apiOptionsGet(optionsContext);
+
+        if (!proxy && frameOffsetForwarder === null) {
+            frameOffsetForwarder = new FrameOffsetForwarder();
+            frameOffsetForwarder.start();
+        }
+
+        let popup;
+        if (isIframe && options.general.showIframePopupsInRootFrame) {
+            popup = popups.iframe || await createIframePopupProxy(url, frameOffsetForwarder);
+            popups.iframe = popup;
+        } else if (proxy) {
+            popup = popups.proxy || await createPopupProxy(depth, id, parentFrameId, url);
+            popups.proxy = popup;
+        } else {
+            popup = popups.normal || await getOrCreatePopup(depth);
+            popups.normal = popup;
+        }
+
+        if (frontend === null) {
+            frontend = new Frontend(popup);
+            frontendPreparePromise = frontend.prepare();
+            await frontendPreparePromise;
+        } else {
+            await frontendPreparePromise;
+            if (isSearchPage) {
+                const disabled = !options.scanning.enableOnSearchPage;
+                frontend.setDisabledOverride(disabled);
+            }
+
+            if (isIframe) {
+                await frontend.setPopup(popup);
             }
-        );
-        apiForward('rootPopupRequestInformationBroadcast');
-        const {popupId, frameId} = await rootPopupInformationPromise;
-
-        const frameOffsetForwarder = new FrameOffsetForwarder();
-        frameOffsetForwarder.start();
-        const getFrameOffset = frameOffsetForwarder.getOffset.bind(frameOffsetForwarder);
-
-        popup = new PopupProxy(popupId, 0, null, frameId, url, getFrameOffset);
-        await popup.prepare();
-    } else if (proxy) {
-        popup = new PopupProxy(null, depth + 1, id, parentFrameId, url);
-        await popup.prepare();
-    } else {
-        const frameOffsetForwarder = new FrameOffsetForwarder();
-        frameOffsetForwarder.start();
-
-        const popupHost = new PopupProxyHost();
-        await popupHost.prepare();
-
-        popup = popupHost.getOrCreatePopup(null, null, depth);
-    }
-
-    const frontend = new Frontend(popup);
-    await frontend.prepare();
+        }
+    };
+
+    yomichan.on('optionsUpdated', applyOptions);
+
+    await applyOptions();
 }
 
 main();
diff --git a/ext/fg/js/frontend.js b/ext/fg/js/frontend.js
index 6fbbd0fb..eecfe2e1 100644
--- a/ext/fg/js/frontend.js
+++ b/ext/fg/js/frontend.js
@@ -17,7 +17,7 @@
 
 /* global
  * TextScanner
- * apiForward
+ * apiBroadcastTab
  * apiGetZoom
  * apiKanjiFind
  * apiOptionsGet
@@ -29,11 +29,14 @@ class Frontend extends TextScanner {
     constructor(popup) {
         super(
             window,
-            popup.isProxy() ? [] : [popup.getContainer()],
+            () => this.popup.isProxy() ? [] : [this.popup.getContainer()],
             [(x, y) => this.popup.containsPoint(x, y)]
         );
 
         this.popup = popup;
+
+        this._disabledOverride = false;
+
         this.options = null;
 
         this.optionsContext = {
@@ -43,7 +46,7 @@ class Frontend extends TextScanner {
 
         this._pageZoomFactor = 1.0;
         this._contentScale = 1.0;
-        this._orphaned = true;
+        this._orphaned = false;
         this._lastShowPromise = Promise.resolve();
 
         this._windowMessageHandlers = new Map([
@@ -132,8 +135,20 @@ class Frontend extends TextScanner {
         ];
     }
 
+    setDisabledOverride(disabled) {
+        this._disabledOverride = disabled;
+        this.setEnabled(this.options.general.enable, this._canEnable());
+    }
+
+    async setPopup(popup) {
+        this.onSearchClear(false);
+        this.popup = popup;
+        await popup.setOptions(this.options);
+    }
+
     async updateOptions() {
-        this.setOptions(await apiOptionsGet(this.getOptionsContext()));
+        this.options = await apiOptionsGet(this.getOptionsContext());
+        this.setOptions(this.options, this._canEnable());
 
         const ignoreNodes = ['.scan-disable', '.scan-disable *'];
         if (!this.options.scanning.enableOnPopupExpressions) {
@@ -259,19 +274,23 @@ class Frontend extends TextScanner {
     }
 
     _broadcastRootPopupInformation() {
-        if (!this.popup.isProxy() && this.popup.depth === 0) {
-            apiForward('rootPopupInformation', {popupId: this.popup.id, frameId: this.popup.frameId});
+        if (!this.popup.isProxy() && this.popup.depth === 0 && this.popup.frameId === 0) {
+            apiBroadcastTab('rootPopupInformation', {popupId: this.popup.id, frameId: this.popup.frameId});
         }
     }
 
     _broadcastDocumentInformation(uniqueId) {
-        apiForward('documentInformationBroadcast', {
+        apiBroadcastTab('documentInformationBroadcast', {
             uniqueId,
             frameId: this.popup.frameId,
             title: document.title
         });
     }
 
+    _canEnable() {
+        return this.popup.depth <= this.options.scanning.popupNestingMaxDepth && !this._disabledOverride;
+    }
+
     async _updatePopupPosition() {
         const textSource = this.getCurrentTextSource();
         if (textSource !== null && await this.popup.isVisible()) {
diff --git a/ext/fg/js/popup-nested.js b/ext/fg/js/popup-nested.js
index 1b24614b..c140f9c8 100644
--- a/ext/fg/js/popup-nested.js
+++ b/ext/fg/js/popup-nested.js
@@ -19,24 +19,7 @@
  * apiOptionsGet
  */
 
-let popupNestedInitialized = false;
-
-async function popupNestedInitialize(id, depth, parentFrameId, url) {
-    if (popupNestedInitialized) {
-        return;
-    }
-    popupNestedInitialized = true;
-
-    const optionsContext = {depth, url};
-    const options = await apiOptionsGet(optionsContext);
-    const popupNestingMaxDepth = options.scanning.popupNestingMaxDepth;
-
-    if (!(typeof popupNestingMaxDepth === 'number' && typeof depth === 'number' && depth < popupNestingMaxDepth)) {
-        return;
-    }
-
-    window.frontendInitializationData = {id, depth, parentFrameId, url, proxy: true};
-
+function injectPopupNested() {
     const scriptSrcs = [
         '/mixed/js/text-scanner.js',
         '/fg/js/frontend-api-sender.js',
@@ -52,3 +35,33 @@ async function popupNestedInitialize(id, depth, parentFrameId, url) {
         document.body.appendChild(script);
     }
 }
+
+async function popupNestedInitialize(id, depth, parentFrameId, url) {
+    let optionsApplied = false;
+
+    const applyOptions = async () => {
+        const optionsContext = {depth, url};
+        const options = await apiOptionsGet(optionsContext);
+        const popupNestingMaxDepth = options.scanning.popupNestingMaxDepth;
+
+        const maxPopupDepthExceeded = !(
+            typeof popupNestingMaxDepth === 'number' &&
+            typeof depth === 'number' &&
+            depth < popupNestingMaxDepth
+        );
+        if (maxPopupDepthExceeded || optionsApplied) {
+            return;
+        }
+
+        optionsApplied = true;
+
+        window.frontendInitializationData = {id, depth, parentFrameId, url, proxy: true};
+        injectPopupNested();
+
+        yomichan.off('optionsUpdated', applyOptions);
+    };
+
+    yomichan.on('optionsUpdated', applyOptions);
+
+    await applyOptions();
+}
diff --git a/ext/mixed/css/display.css b/ext/mixed/css/display.css
index 92ba52c6..d1a54064 100644
--- a/ext/mixed/css/display.css
+++ b/ext/mixed/css/display.css
@@ -297,13 +297,13 @@ button.action-button {
     content: "\3001";
 }
 
-.term-expression-list[data-multi=true]>.term-expression:last-of-type:after {
+.entry[data-expression-multi=true] .term-expression-list>.term-expression:last-of-type:after {
     font-size: 2em;
     content: "\3000";
     visibility: hidden;
 }
 
-.term-expression-list[data-multi=true] .term-expression-details {
+.entry[data-expression-multi=true] .term-expression-list .term-expression-details {
     display: inline-block;
     position: relative;
     width: 0;
@@ -312,21 +312,21 @@ button.action-button {
     z-index: 1;
 }
 
-.term-expression-list[data-multi=true] .term-expression:hover .term-expression-details {
+.entry[data-expression-multi=true] .term-expression:hover .term-expression-details {
     visibility: visible;
 }
 
-.term-expression-list[data-multi=true] .term-expression-details>.action-play-audio {
+.entry[data-expression-multi=true] .term-expression-list .term-expression-details>.action-play-audio {
     position: absolute;
     left: 0;
     bottom: 0.5em;
 }
 
-.term-expression-list:not([data-multi=true]) .term-expression-details>.action-play-audio {
+.entry:not([data-expression-multi=true]) .term-expression-list .term-expression-details>.action-play-audio {
     display: none;
 }
 
-.term-expression-list[data-multi=true] .term-expression-details>.tags {
+.entry[data-expression-multi=true] .term-expression-list .term-expression-details>.tags {
     display: block;
     position: absolute;
     left: 0;
@@ -334,7 +334,7 @@ button.action-button {
     white-space: nowrap;
 }
 
-.term-expression-list[data-multi=true] .term-expression-details>.frequencies {
+.entry[data-expression-multi=true] .term-expression-list .term-expression-details>.frequencies {
     display: block;
     position: absolute;
     left: 0;
@@ -364,19 +364,19 @@ button.action-button {
     list-style-type: circle;
 }
 
-.term-definition-only-list[data-count="0"] {
+.term-definition-disambiguation-list[data-count="0"] {
     display: none;
 }
 
-.term-definition-only-list:before {
+.term-definition-disambiguation-list:before {
     content: "(";
 }
 
-.term-definition-only-list:after {
+.term-definition-disambiguation-list:after {
     content: " only)";
 }
 
-.term-definition-only+.term-definition-only:before {
+.term-definition-disambiguation+.term-definition-disambiguation:before {
     content: ", ";
 }
 
@@ -398,7 +398,7 @@ button.action-button {
 }
 
 :root[data-compact-glossaries=true] .term-definition-tag-list,
-:root[data-compact-glossaries=true] .term-definition-only-list:not([data-count="0"]) {
+:root[data-compact-glossaries=true] .term-definition-disambiguation-list:not([data-count="0"]) {
     display: inline;
 }
 
diff --git a/ext/mixed/display-templates.html b/ext/mixed/display-templates.html
index b8d52d15..3baa8293 100644
--- a/ext/mixed/display-templates.html
+++ b/ext/mixed/display-templates.html
@@ -30,10 +30,10 @@
 </div></div></template>
 <template id="term-definition-item-template"><li class="term-definition-item">
     <div class="term-definition-tag-list tag-list"></div>
-    <div class="term-definition-only-list"></div>
+    <div class="term-definition-disambiguation-list"></div>
     <ul class="term-glossary-list"></ul>
 </li></template>
-<template id="term-definition-only-template"><span class="term-definition-only"></span></template>
+<template id="term-definition-disambiguation-template"><span class="term-definition-disambiguation"></span></template>
 <template id="term-glossary-item-template"><li class="term-glossary-item"><span class="term-glossary-separator"> </span><span class="term-glossary"></span></li></template>
 <template id="term-reason-template"><span class="term-reason"></span><span class="term-reason-separator"> </span></template>
 
diff --git a/ext/mixed/js/api.js b/ext/mixed/js/api.js
index 066077cf..30c08347 100644
--- a/ext/mixed/js/api.js
+++ b/ext/mixed/js/api.js
@@ -44,10 +44,6 @@ function apiTextParse(text, optionsContext) {
     return _apiInvoke('textParse', {text, optionsContext});
 }
 
-function apiTextParseMecab(text, optionsContext) {
-    return _apiInvoke('textParseMecab', {text, optionsContext});
-}
-
 function apiKanjiFind(text, optionsContext) {
     return _apiInvoke('kanjiFind', {text, optionsContext});
 }
@@ -80,8 +76,8 @@ function apiScreenshotGet(options) {
     return _apiInvoke('screenshotGet', {options});
 }
 
-function apiForward(action, params) {
-    return _apiInvoke('forward', {action, params});
+function apiBroadcastTab(action, params) {
+    return _apiInvoke('broadcastTab', {action, params});
 }
 
 function apiFrameInformationGet() {
diff --git a/ext/mixed/js/display-generator.js b/ext/mixed/js/display-generator.js
index b0cc2478..0f991362 100644
--- a/ext/mixed/js/display-generator.js
+++ b/ext/mixed/js/display-generator.js
@@ -43,13 +43,15 @@ class DisplayGenerator {
         const debugInfoContainer = node.querySelector('.debug-info');
         const bodyContainer = node.querySelector('.term-entry-body');
 
-        const pitches = DisplayGenerator._getPitchInfos(details);
+        const {termTags, expressions, definitions} = details;
+
+        const pitches = this._getPitchInfos(details);
         const pitchCount = pitches.reduce((i, v) => i + v[1].length, 0);
 
-        const expressionMulti = Array.isArray(details.expressions);
-        const definitionMulti = Array.isArray(details.definitions);
-        const expressionCount = expressionMulti ? details.expressions.length : 1;
-        const definitionCount = definitionMulti ? details.definitions.length : 1;
+        const expressionMulti = Array.isArray(expressions);
+        const definitionMulti = Array.isArray(definitions);
+        const expressionCount = expressionMulti ? expressions.length : 1;
+        const definitionCount = definitionMulti ? definitions.length : 1;
         const uniqueExpressionCount = Array.isArray(details.expression) ? new Set(details.expression).size : 1;
 
         node.dataset.expressionMulti = `${expressionMulti}`;
@@ -65,15 +67,56 @@ class DisplayGenerator {
             (pitches.length > 0 ? 1 : 0)
         }`;
 
-        const termTags = details.termTags;
-        let expressions = details.expressions;
-        expressions = Array.isArray(expressions) ? expressions.map((e) => [e, termTags]) : null;
+        this._appendMultiple(expressionsContainer, this._createTermExpression.bind(this), expressionMulti ? expressions : [details], termTags);
+        this._appendMultiple(reasonsContainer, this._createTermReason.bind(this), details.reasons);
+        this._appendMultiple(frequenciesContainer, this._createFrequencyTag.bind(this), details.frequencies);
+        this._appendMultiple(pitchesContainer, this._createPitches.bind(this), pitches);
+        this._appendMultiple(definitionsContainer, this._createTermDefinitionItem.bind(this), definitionMulti ? definitions : [details]);
+
+        if (debugInfoContainer !== null) {
+            debugInfoContainer.textContent = JSON.stringify(details, null, 4);
+        }
+
+        return node;
+    }
+
+    createKanjiEntry(details) {
+        const node = this._templateHandler.instantiate('kanji-entry');
+
+        const glyphContainer = node.querySelector('.kanji-glyph');
+        const frequenciesContainer = node.querySelector('.frequencies');
+        const tagContainer = node.querySelector('.tags');
+        const glossaryContainer = node.querySelector('.kanji-glossary-list');
+        const chineseReadingsContainer = node.querySelector('.kanji-readings-chinese');
+        const japaneseReadingsContainer = node.querySelector('.kanji-readings-japanese');
+        const statisticsContainer = node.querySelector('.kanji-statistics');
+        const classificationsContainer = node.querySelector('.kanji-classifications');
+        const codepointsContainer = node.querySelector('.kanji-codepoints');
+        const dictionaryIndicesContainer = node.querySelector('.kanji-dictionary-indices');
+        const debugInfoContainer = node.querySelector('.debug-info');
+
+        if (glyphContainer !== null) {
+            glyphContainer.textContent = details.character;
+        }
 
-        DisplayGenerator._appendMultiple(expressionsContainer, this.createTermExpression.bind(this), expressions, [[details, termTags]]);
-        DisplayGenerator._appendMultiple(reasonsContainer, this.createTermReason.bind(this), details.reasons);
-        DisplayGenerator._appendMultiple(frequenciesContainer, this.createFrequencyTag.bind(this), details.frequencies);
-        DisplayGenerator._appendMultiple(pitchesContainer, this.createPitches.bind(this), pitches);
-        DisplayGenerator._appendMultiple(definitionsContainer, this.createTermDefinitionItem.bind(this), details.definitions, [details]);
+        this._appendMultiple(frequenciesContainer, this._createFrequencyTag.bind(this), details.frequencies);
+        this._appendMultiple(tagContainer, this._createTag.bind(this), details.tags);
+        this._appendMultiple(glossaryContainer, this._createKanjiGlossaryItem.bind(this), details.glossary);
+        this._appendMultiple(chineseReadingsContainer, this._createKanjiReading.bind(this), details.onyomi);
+        this._appendMultiple(japaneseReadingsContainer, this._createKanjiReading.bind(this), details.kunyomi);
+
+        if (statisticsContainer !== null) {
+            statisticsContainer.appendChild(this._createKanjiInfoTable(details.stats.misc));
+        }
+        if (classificationsContainer !== null) {
+            classificationsContainer.appendChild(this._createKanjiInfoTable(details.stats.class));
+        }
+        if (codepointsContainer !== null) {
+            codepointsContainer.appendChild(this._createKanjiInfoTable(details.stats.code));
+        }
+        if (dictionaryIndicesContainer !== null) {
+            dictionaryIndicesContainer.appendChild(this._createKanjiInfoTable(details.stats.index));
+        }
 
         if (debugInfoContainer !== null) {
             debugInfoContainer.textContent = JSON.stringify(details, null, 4);
@@ -82,7 +125,9 @@ class DisplayGenerator {
         return node;
     }
 
-    createTermExpression([details, termTags]) {
+    // Private
+
+    _createTermExpression(details, termTags) {
         const node = this._templateHandler.instantiate('term-expression');
 
         const expressionContainer = node.querySelector('.term-expression-text');
@@ -99,7 +144,7 @@ class DisplayGenerator {
                 // This case should not occur
                 furiganaSegments = [{text: details.expression, furigana: details.reading}];
             }
-            DisplayGenerator._appendFurigana(expressionContainer, furiganaSegments, this._appendKanjiLinks.bind(this));
+            this._appendFurigana(expressionContainer, furiganaSegments, this._appendKanjiLinks.bind(this));
         }
 
         if (!Array.isArray(termTags)) {
@@ -109,14 +154,14 @@ class DisplayGenerator {
         const searchQueries = [details.expression, details.reading]
             .filter((x) => !!x)
             .map((x) => ({query: x}));
-        DisplayGenerator._appendMultiple(tagContainer, this.createTag.bind(this), termTags);
-        DisplayGenerator._appendMultiple(tagContainer, this.createSearchTag.bind(this), searchQueries);
-        DisplayGenerator._appendMultiple(frequencyContainer, this.createFrequencyTag.bind(this), details.frequencies);
+        this._appendMultiple(tagContainer, this._createTag.bind(this), termTags);
+        this._appendMultiple(tagContainer, this._createSearchTag.bind(this), searchQueries);
+        this._appendMultiple(frequencyContainer, this._createFrequencyTag.bind(this), details.frequencies);
 
         return node;
     }
 
-    createTermReason(reason) {
+    _createTermReason(reason) {
         const fragment = this._templateHandler.instantiateFragment('term-reason');
         const node = fragment.querySelector('.term-reason');
         node.textContent = reason;
@@ -124,39 +169,39 @@ class DisplayGenerator {
         return fragment;
     }
 
-    createTermDefinitionItem(details) {
+    _createTermDefinitionItem(details) {
         const node = this._templateHandler.instantiate('term-definition-item');
 
         const tagListContainer = node.querySelector('.term-definition-tag-list');
-        const onlyListContainer = node.querySelector('.term-definition-only-list');
+        const onlyListContainer = node.querySelector('.term-definition-disambiguation-list');
         const glossaryContainer = node.querySelector('.term-glossary-list');
 
         node.dataset.dictionary = details.dictionary;
 
-        DisplayGenerator._appendMultiple(tagListContainer, this.createTag.bind(this), details.definitionTags);
-        DisplayGenerator._appendMultiple(onlyListContainer, this.createTermOnly.bind(this), details.only);
-        DisplayGenerator._appendMultiple(glossaryContainer, this.createTermGlossaryItem.bind(this), details.glossary);
+        this._appendMultiple(tagListContainer, this._createTag.bind(this), details.definitionTags);
+        this._appendMultiple(onlyListContainer, this._createTermDisambiguation.bind(this), details.only);
+        this._appendMultiple(glossaryContainer, this._createTermGlossaryItem.bind(this), details.glossary);
 
         return node;
     }
 
-    createTermGlossaryItem(glossary) {
+    _createTermGlossaryItem(glossary) {
         const node = this._templateHandler.instantiate('term-glossary-item');
         const container = node.querySelector('.term-glossary');
         if (container !== null) {
-            DisplayGenerator._appendMultilineText(container, glossary);
+            this._appendMultilineText(container, glossary);
         }
         return node;
     }
 
-    createTermOnly(only) {
-        const node = this._templateHandler.instantiate('term-definition-only');
-        node.dataset.only = only;
-        node.textContent = only;
+    _createTermDisambiguation(disambiguation) {
+        const node = this._templateHandler.instantiate('term-definition-disambiguation');
+        node.dataset.term = disambiguation;
+        node.textContent = disambiguation;
         return node;
     }
 
-    createKanjiLink(character) {
+    _createKanjiLink(character) {
         const node = document.createElement('a');
         node.href = '#';
         node.className = 'kanji-link';
@@ -164,75 +209,30 @@ class DisplayGenerator {
         return node;
     }
 
-    createKanjiEntry(details) {
-        const node = this._templateHandler.instantiate('kanji-entry');
-
-        const glyphContainer = node.querySelector('.kanji-glyph');
-        const frequenciesContainer = node.querySelector('.frequencies');
-        const tagContainer = node.querySelector('.tags');
-        const glossaryContainer = node.querySelector('.kanji-glossary-list');
-        const chineseReadingsContainer = node.querySelector('.kanji-readings-chinese');
-        const japaneseReadingsContainer = node.querySelector('.kanji-readings-japanese');
-        const statisticsContainer = node.querySelector('.kanji-statistics');
-        const classificationsContainer = node.querySelector('.kanji-classifications');
-        const codepointsContainer = node.querySelector('.kanji-codepoints');
-        const dictionaryIndicesContainer = node.querySelector('.kanji-dictionary-indices');
-        const debugInfoContainer = node.querySelector('.debug-info');
-
-        if (glyphContainer !== null) {
-            glyphContainer.textContent = details.character;
-        }
-
-        DisplayGenerator._appendMultiple(frequenciesContainer, this.createFrequencyTag.bind(this), details.frequencies);
-        DisplayGenerator._appendMultiple(tagContainer, this.createTag.bind(this), details.tags);
-        DisplayGenerator._appendMultiple(glossaryContainer, this.createKanjiGlossaryItem.bind(this), details.glossary);
-        DisplayGenerator._appendMultiple(chineseReadingsContainer, this.createKanjiReading.bind(this), details.onyomi);
-        DisplayGenerator._appendMultiple(japaneseReadingsContainer, this.createKanjiReading.bind(this), details.kunyomi);
-
-        if (statisticsContainer !== null) {
-            statisticsContainer.appendChild(this.createKanjiInfoTable(details.stats.misc));
-        }
-        if (classificationsContainer !== null) {
-            classificationsContainer.appendChild(this.createKanjiInfoTable(details.stats.class));
-        }
-        if (codepointsContainer !== null) {
-            codepointsContainer.appendChild(this.createKanjiInfoTable(details.stats.code));
-        }
-        if (dictionaryIndicesContainer !== null) {
-            dictionaryIndicesContainer.appendChild(this.createKanjiInfoTable(details.stats.index));
-        }
-
-        if (debugInfoContainer !== null) {
-            debugInfoContainer.textContent = JSON.stringify(details, null, 4);
-        }
-
-        return node;
-    }
-
-    createKanjiGlossaryItem(glossary) {
+    _createKanjiGlossaryItem(glossary) {
         const node = this._templateHandler.instantiate('kanji-glossary-item');
         const container = node.querySelector('.kanji-glossary');
         if (container !== null) {
-            DisplayGenerator._appendMultilineText(container, glossary);
+            this._appendMultilineText(container, glossary);
         }
         return node;
     }
 
-    createKanjiReading(reading) {
+    _createKanjiReading(reading) {
         const node = this._templateHandler.instantiate('kanji-reading');
         node.textContent = reading;
         return node;
     }
 
-    createKanjiInfoTable(details) {
+    _createKanjiInfoTable(details) {
         const node = this._templateHandler.instantiate('kanji-info-table');
 
         const container = node.querySelector('.kanji-info-table-body');
 
         if (container !== null) {
-            const count = DisplayGenerator._appendMultiple(container, this.createKanjiInfoTableItem.bind(this), details);
+            const count = this._appendMultiple(container, this._createKanjiInfoTableItem.bind(this), details);
             if (count === 0) {
-                const n = this.createKanjiInfoTableItemEmpty();
+                const n = this._createKanjiInfoTableItemEmpty();
                 container.appendChild(n);
             }
         }
@@ -240,7 +240,7 @@ class DisplayGenerator {
         return node;
     }
 
-    createKanjiInfoTableItem(details) {
+    _createKanjiInfoTableItem(details) {
         const node = this._templateHandler.instantiate('kanji-info-table-item');
         const nameNode = node.querySelector('.kanji-info-table-item-header');
         const valueNode = node.querySelector('.kanji-info-table-item-value');
@@ -253,11 +253,11 @@ class DisplayGenerator {
         return node;
     }
 
-    createKanjiInfoTableItemEmpty() {
+    _createKanjiInfoTableItemEmpty() {
         return this._templateHandler.instantiate('kanji-info-table-empty');
     }
 
-    createTag(details) {
+    _createTag(details) {
         const node = this._templateHandler.instantiate('tag');
 
         const inner = node.querySelector('.tag-inner');
@@ -269,7 +269,7 @@ class DisplayGenerator {
         return node;
     }
 
-    createSearchTag(details) {
+    _createSearchTag(details) {
         const node = this._templateHandler.instantiate('tag-search');
 
         node.textContent = details.query;
@@ -279,7 +279,7 @@ class DisplayGenerator {
         return node;
     }
 
-    createPitches(details) {
+    _createPitches(details) {
         if (!this._termPitchAccentStaticTemplateIsSetup) {
             this._termPitchAccentStaticTemplateIsSetup = true;
             const t = this._templateHandler.instantiate('term-pitch-accent-static');
@@ -293,16 +293,16 @@ class DisplayGenerator {
         node.dataset.pitchesMulti = 'true';
         node.dataset.pitchesCount = `${dictionaryPitches.length}`;
 
-        const tag = this.createTag({notes: '', name: dictionary, category: 'pitch-accent-dictionary'});
+        const tag = this._createTag({notes: '', name: dictionary, category: 'pitch-accent-dictionary'});
         node.querySelector('.term-pitch-accent-group-tag-list').appendChild(tag);
 
         const n = node.querySelector('.term-pitch-accent-list');
-        DisplayGenerator._appendMultiple(n, this.createPitch.bind(this), dictionaryPitches);
+        this._appendMultiple(n, this._createPitch.bind(this), dictionaryPitches);
 
         return node;
     }
 
-    createPitch(details) {
+    _createPitch(details) {
         const {reading, position, tags, exclusiveExpressions, exclusiveReadings} = details;
         const morae = jp.getKanaMorae(reading);
 
@@ -315,10 +315,10 @@ class DisplayGenerator {
         n.textContent = `${position}`;
 
         n = node.querySelector('.term-pitch-accent-tag-list');
-        DisplayGenerator._appendMultiple(n, this.createTag.bind(this), tags);
+        this._appendMultiple(n, this._createTag.bind(this), tags);
 
         n = node.querySelector('.term-pitch-accent-disambiguation-list');
-        this.createPitchAccentDisambiguations(n, exclusiveExpressions, exclusiveReadings);
+        this._createPitchAccentDisambiguations(n, exclusiveExpressions, exclusiveReadings);
 
         n = node.querySelector('.term-pitch-accent-characters');
         for (let i = 0, ii = morae.length; i < ii; ++i) {
@@ -338,13 +338,13 @@ class DisplayGenerator {
         }
 
         if (morae.length > 0) {
-            this.populatePitchGraph(node.querySelector('.term-pitch-accent-graph'), position, morae);
+            this._populatePitchGraph(node.querySelector('.term-pitch-accent-graph'), position, morae);
         }
 
         return node;
     }
 
-    createPitchAccentDisambiguations(container, exclusiveExpressions, exclusiveReadings) {
+    _createPitchAccentDisambiguations(container, exclusiveExpressions, exclusiveReadings) {
         const templateName = 'term-pitch-accent-disambiguation';
         for (const exclusiveExpression of exclusiveExpressions) {
             const node = this._templateHandler.instantiate(templateName);
@@ -360,13 +360,12 @@ class DisplayGenerator {
             container.appendChild(node);
         }
 
-        container.dataset.multi = 'true';
         container.dataset.count = `${exclusiveExpressions.length + exclusiveReadings.length}`;
         container.dataset.expressionCount = `${exclusiveExpressions.length}`;
         container.dataset.readingCount = `${exclusiveReadings.length}`;
     }
 
-    populatePitchGraph(svg, position, morae) {
+    _populatePitchGraph(svg, position, morae) {
         const svgns = svg.getAttribute('xmlns');
         const ii = morae.length;
         svg.setAttribute('viewBox', `0 0 ${50 * (ii + 1)} 100`);
@@ -406,7 +405,7 @@ class DisplayGenerator {
         path.setAttribute('d', `M${pathPoints.join(' L')}`);
     }
 
-    createFrequencyTag(details) {
+    _createFrequencyTag(details) {
         const node = this._templateHandler.instantiate('tag-frequency');
 
         let n = node.querySelector('.term-frequency-dictionary-name');
@@ -434,7 +433,7 @@ class DisplayGenerator {
                     part = '';
                 }
 
-                const link = this.createKanjiLink(c);
+                const link = this._createKanjiLink(c);
                 container.appendChild(link);
             } else {
                 part += c;
@@ -445,31 +444,31 @@ class DisplayGenerator {
         }
     }
 
-    static _appendMultiple(container, createItem, detailsIterable, fallback=[]) {
-        if (container === null) { return 0; }
-
-        const multi = (
-            detailsIterable !== null &&
-            typeof detailsIterable === 'object' &&
-            typeof detailsIterable[Symbol.iterator] !== 'undefined'
+    _isIterable(value) {
+        return (
+            value !== null &&
+            typeof value === 'object' &&
+            typeof value[Symbol.iterator] !== 'undefined'
         );
-        if (!multi) { detailsIterable = fallback; }
+    }
 
+    _appendMultiple(container, createItem, detailsIterable, ...args) {
         let count = 0;
-        for (const details of detailsIterable) {
-            const item = createItem(details);
-            if (item === null) { continue; }
-            container.appendChild(item);
-            ++count;
+        if (container !== null && this._isIterable(detailsIterable)) {
+            for (const details of detailsIterable) {
+                const item = createItem(details, ...args);
+                if (item === null) { continue; }
+                container.appendChild(item);
+                ++count;
+            }
         }
 
-        container.dataset.multi = `${multi}`;
         container.dataset.count = `${count}`;
 
         return count;
     }
 
-    static _appendFurigana(container, segments, addText) {
+    _appendFurigana(container, segments, addText) {
         for (const {text, furigana} of segments) {
             if (furigana) {
                 const ruby = document.createElement('ruby');
@@ -484,7 +483,7 @@ class DisplayGenerator {
         }
     }
 
-    static _appendMultilineText(container, text) {
+    _appendMultilineText(container, text) {
         const parts = text.split('\n');
         container.appendChild(document.createTextNode(parts[0]));
         for (let i = 1, ii = parts.length; i < ii; ++i) {
@@ -493,7 +492,7 @@ class DisplayGenerator {
         }
     }
 
-    static _getPitchInfos(definition) {
+    _getPitchInfos(definition) {
         const results = new Map();
 
         const allExpressions = new Set();
@@ -511,7 +510,7 @@ class DisplayGenerator {
                 }
 
                 for (const {position, tags} of pitches) {
-                    let pitchInfo = DisplayGenerator._findExistingPitchInfo(reading, position, tags, dictionaryResults);
+                    let pitchInfo = this._findExistingPitchInfo(reading, position, tags, dictionaryResults);
                     if (pitchInfo === null) {
                         pitchInfo = {expressions: new Set(), reading, position, tags};
                         dictionaryResults.push(pitchInfo);
@@ -540,12 +539,12 @@ class DisplayGenerator {
         return [...results.entries()];
     }
 
-    static _findExistingPitchInfo(reading, position, tags, pitchInfoList) {
+    _findExistingPitchInfo(reading, position, tags, pitchInfoList) {
         for (const pitchInfo of pitchInfoList) {
             if (
                 pitchInfo.reading === reading &&
                 pitchInfo.position === position &&
-                DisplayGenerator._areTagListsEqual(pitchInfo.tags, tags)
+                this._areTagListsEqual(pitchInfo.tags, tags)
             ) {
                 return pitchInfo;
             }
@@ -553,7 +552,7 @@ class DisplayGenerator {
         return null;
     }
 
-    static _areTagListsEqual(tagList1, tagList2) {
+    _areTagListsEqual(tagList1, tagList2) {
         const ii = tagList1.length;
         if (tagList2.length !== ii) { return false; }
 
diff --git a/ext/mixed/js/display.js b/ext/mixed/js/display.js
index bf6990a1..63687dc2 100644
--- a/ext/mixed/js/display.js
+++ b/ext/mixed/js/display.js
@@ -22,9 +22,9 @@
  * DisplayGenerator
  * WindowScroll
  * apiAudioGetUri
+ * apiBroadcastTab
  * apiDefinitionAdd
  * apiDefinitionsAddable
- * apiForward
  * apiKanjiFind
  * apiNoteView
  * apiOptionsGet
@@ -854,7 +854,7 @@ class Display {
     }
 
     setPopupVisibleOverride(visible) {
-        return apiForward('popupSetVisibleOverride', {visible});
+        return apiBroadcastTab('popupSetVisibleOverride', {visible});
     }
 
     setSpinnerVisible(visible) {
diff --git a/ext/mixed/js/text-scanner.js b/ext/mixed/js/text-scanner.js
index a1d96320..0cd12cd7 100644
--- a/ext/mixed/js/text-scanner.js
+++ b/ext/mixed/js/text-scanner.js
@@ -46,7 +46,7 @@ class TextScanner {
     }
 
     onMouseOver(e) {
-        if (this.ignoreElements.includes(e.target)) {
+        if (this.ignoreElements().includes(e.target)) {
             this.scanTimerClear();
         }
     }
@@ -133,7 +133,7 @@ class TextScanner {
         this.preventNextClick = false;
 
         const primaryTouch = e.changedTouches[0];
-        if (DOM.isPointInSelection(primaryTouch.clientX, primaryTouch.clientY, this.node.getSelection())) {
+        if (DOM.isPointInSelection(primaryTouch.clientX, primaryTouch.clientY, window.getSelection())) {
             return;
         }
 
@@ -224,8 +224,8 @@ class TextScanner {
         }
     }
 
-    setEnabled(enabled) {
-        if (enabled) {
+    setEnabled(enabled, canEnable) {
+        if (enabled && canEnable) {
             if (!this.enabled) {
                 this.hookEvents();
                 this.enabled = true;
@@ -271,9 +271,9 @@ class TextScanner {
         ];
     }
 
-    setOptions(options) {
+    setOptions(options, canEnable=true) {
         this.options = options;
-        this.setEnabled(this.options.general.enable);
+        this.setEnabled(this.options.general.enable, canEnable);
     }
 
     async searchAt(x, y, cause) {