Merge branch 'main' into refactor-class-scope

Fix glob pattern matching for filenames with special characters (#335 )
2026-01-26 19:19:57 +00:00 · 2025-11-11 11:21:09 +01:00 · 2025-11-11 11:20:18 +01:00 · 2025-09-09 10:13:06 +02:00 · 2025-09-09 10:04:00 +02:00 · 2025-09-09 09:57:50 +02:00
32 changed files with 874319 additions and 200615 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 tags/temp/
 __pycache__/
+tags/tag_frequency.db
--- a/README.md
+++ b/README.md
@@ -23,11 +23,12 @@ Booru style tag autocompletion for the AUTOMATIC1111 Stable Diffusion WebUI
 # 📄 Description

 Tag Autocomplete is an extension for the popular [AUTOMATIC1111 web UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) for Stable Diffusion.
+You can install it using the inbuilt available extensions list, clone the files manually as described [below](#-installation), or use a pre-packaged version from [Releases](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/releases).

 It displays autocompletion hints for recognized tags from "image booru" boards such as Danbooru, which are primarily used for browsing Anime-style illustrations.
-Since some Stable Diffusion models were trained using this information, for example [Waifu Diffusion](https://github.com/harubaru/waifu-diffusion) and many of the NAI-descendant models or merges, using exact tags in prompts can often improve composition and consistency.
+Since most custom Stable Diffusion models were trained using this information or merged with ones that did, using exact tags in prompts can often improve composition and consistency, even if the model itself has a photorealistic style.

-You can install it using the inbuilt available extensions list, clone the files manually as described [below](#-installation), or use a pre-packaged version from [Releases](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/releases).
+Disclaimer: The default tag lists contain NSFW terms, please use them responsibly.

 <br/>

@@ -42,7 +43,7 @@ You can install it using the inbuilt available extensions list, clone the files
 Tag autocomplete supports built-in completion for:
 - 🏷️ **Danbooru & e621 tags** (Top 100k by post count, as of November 2022)
 - ✳️ [**Wildcards**](#wildcards)
- ➕ [**Extra network**](#extra-networks-embeddings-hypernets-lora) filenames, including
+- ➕ [**Extra network**](#extra-networks-embeddings-hypernets-lora-) filenames, including
   - Textual Inversion embeddings [(jump to readme section)]
   - Hypernetworks
   - LoRA
@@ -74,6 +75,10 @@ Wildcard script support:

 https://user-images.githubusercontent.com/34448969/200128031-22dd7c33-71d1-464f-ae36-5f6c8fd49df0.mp4

+Extra Network preview support:
+
+https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/3c0cad84-fb5f-436d-b05a-28db35860d13
+
 Dark and Light mode supported, including tag colors:

 ![results_dark](https://user-images.githubusercontent.com/34448969/200128214-3b6f21b4-9dda-4acf-820e-5df0285c30d6.png)
@@ -123,6 +128,49 @@ Completion for these types is triggered by typing `<`. By default it will show t
   - Or `<lora:` and `<lyco:` respectively for the long form
 - `<h:` or `<hypernet:` will only show Hypernetworks

+### Live previews
+Tag Autocomplete will now also show the preview images used for the cards in the Extra Networks menu in a small window next to the regular popup.
+This enables quick comparisons and additional info for unclear filenames without having to stop typing to look it up in the webui menu.
+It works for all supported extra network types that use preview images (Loras/Lycos, Embeddings & Hypernetworks). The preview window will stay hidden for normal tags or if no preview was found.
+
+![extra_live_preview](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/6a5d81e6-b3a0-407b-8bac-c9790f86016c)
+
+### Lora / Lyco trigger word completion
+This feature will try to add known trigger words on autocompleting a Lora/Lyco.
+
+It primarily uses the list provided by the [model-keyword](https://github.com/mix1009/model-keyword/) extension, which thus needs to be installed to use this feature. The list is also regularly updated through it.
+However, once installed, you can deactivate it if you want, since tag autocomplete only needs the local keyword lists it ships with, not the extension itself.
+The used files are `lora-keyword.txt` and `lora-keyword-user.txt` in the model-keyword installation folder.
+If the main file isn't found, the feature will simply deactivate itself, everything else should work normally.
+
+#### Note:
+As of [v1.5.0](https://github.com/AUTOMATIC1111/stable-diffusion-webui/commit/a3ddf464a2ed24c999f67ddfef7969f8291567be), the webui provides a native method to add activation keywords for Lora through the Extra networks config UI.
+These trigger words will always be preferred over the model-keyword ones and can be used without needing to install the model-keyword extension. This will however, obviously, be limited to those manually added keywords. For automatic discovery of keywords, you will still need the big list provided by model-keyword.
+
+Custom trigger words can be added through two methods:
+1. Using the extra networks UI (recommended):
+   - Only works with webui version v1.5.0 upwards, but much easier to use and works without the model-keyword extension
+   - This method requires no manual refresh
+   - <details>
+     <summary>Image example</summary>
+	   
+     ![edit button](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/22e95040-1d85-4b7e-a005-1918fafec807)
+     ![lora_edit](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/3e6c5245-d3bc-498d-8cd2-26eadf8882e7)
+     </details>
+2. Through the model-keyword UI:
+   - One issue with this method is that it has no official support for the Lycoris extension and doesn't scan its folder for files, so to add them through the UI you will have to temporarily move them into the Lora model folder to be able to select them in model-keywords dropdown. Some are already included in the default list though, so trying it out first is advisable.
+   - After having added your custom keywords, you will need to either restart the UI or use the "Refresh TAC temp files" setting button.
+   - <details>
+     <summary>Image example</summary>
+
+     ![image](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/4302c44e-c632-473d-a14a-76f164f966cb)
+     </details>
+
+Sometimes the inserted keywords can be wrong due to a hash collision, however model-keyword and tag autocomplete take the name of the file into account too if the collision is known.
+
+If it still inserts something wrong or you simply don't want the keywords added that time, you can undo / redo it directly after as often as you want, until you type something else
+(It uses the default undo/redo action of the browser, so <kbd>CTRL</kbd> + <kbd>Z</kbd>, context menu and mouse macros should all work).
+
 ### Embedding type filtering
 Embeddings trained for Stable Diffusion 1.x or 2.x models respectively are incompatible with the other type. To make it easier to find valid embeds, they are categorized by "v1 Embedding" and "v2 Embedding", including a slight color difference. You can also filter your search to include only v1 or v2 embeddings by typing `<v1/2` or `<e:v1/2` followed by the actual search term.

@@ -271,6 +319,14 @@ If this option is turned on, it will show a `?` link next to the tag. Clicking t

 ![wikiLink](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/733e1ba8-89e1-4c2b-8c4e-2d23352bd3d7)
 </details>
+<!-- Wiki links -->
+<details>
+<summary>Extra network live previews</summary>
+
+This option enables a small preview window alongside the normal completion popup that will show the card preview also usd in the extra networks tab for that file.
+
+![extraNetworkPreviews](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/72b5473f-563e-4238-a513-38b60ac87e96)
+</details>
 <!-- Insertion -->
 <details>
 <summary>Completion settings</summary>
@@ -285,6 +341,49 @@ Depending on the last setting, tag autocomplete will append a comma and space af

 ![insertEscape](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/d28557be-6c75-43fd-bf17-c0609223b384)
 </details>
+<!-- Lora keywords -->
+<details>
+<summary>Lora / Lyco trigger word insertion</summary>
+
+See [the detailed readme section](#lora--lyco-trigger-word-completion) for more info.
+
+Selects the mode to use for Lora / Lyco trigger word insertion.
+Needs the [model-keyword](https://github.com/mix1009/model-keyword/) extension to be installed, else it will do nothing.
+
+- Never
+   - Will not complete trigger words, even if the model-keyword extension is installed
+- Only user list
+   - Will only load the custom keywords specified in the lora-keyword-user.txt file and ignore the default list
+- Always
+   - Will load and use both lists
+
+Switching from "Never" to what you had before or back will not require a restart, but changing between the full and user only list will.
+
+![loraKeywordCompletion](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/8bec89ea-68f7-4783-b5cb-55869d9121a3)
+</details>
+<!-- Wildcard path mode -->
+<details>
+<summary>Wildcard path completion</summary>
+
+Some collections of wildcards are organized in nested subfolders.
+They are listed with the full path to the file, like "hair/colors/light/..." or "clothing/male/casual/..." etc.
+
+In these cases it is often hard to type the full path manually, but you still want to narrow the selection before further scrolling in the list.
+For this, a partial completion of the path can be triggered with <kbd>Tab</kbd> (or the custom hotkey for `ChooseSelectedOrFirst`) if the results to choose from are all paths. 
+
+This setting determines the mode it should use for completion:
+- To next folder level:
+   - Completes until the next `/` in the path, preferring your selection as the way forward
+   - If you want to directly choose an option, <kbd>Enter</kbd> / the `ChooseSelected` hotkey will skip it and fully complete.
+- To first difference:
+   - Completes until the first difference in the results and waits for additional info
+   - E.g. if you have "/sub/folder_a/..." and "/sub/folder_b/...", completing after typing "su" will insert everything up to "/sub/folder_" and stop there until you type a or b to clarify.
+   - If you selected something with the arrow keys (regardless of pressing Enter or Tab), it will skip it and fully complete.
+- Always fully:
+   - As the name suggests, disables the partial completion behavior and inserts the full path under all circumstances like with normal tags.
+
+![insertWildcardPath](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/ed354bd1-3f23-4fb1-a638-ac3b7a213fc5)
+</details>
 <!-- Alias -->
 <details>
 <summary>Alias settings</summary>
@@ -376,7 +475,9 @@ You can also add this to your quicksettings bar to have the refresh button avail

 # Translations
 An additional file can be added in the translation section, which will be used to translate both tags and aliases and also enables searching by translation.
-This file needs to be a CSV in the format `<English tag/alias>,<Translation>`, but for backwards compatibility with older files that used a three column format, you can turn on `Translation file uses old 3-column translation format instead of the new 2-column one` to support them. In that case, the second column will be unused and skipped during parsing.
+This file needs to be a CSV in the format `<English tag/alias>,<Translation>`. Some older files use a three column format, which requires a compatibility setting to be activated.
+You can find it under `Settings > Tag autocomplete > Translation filename > Translation file uses old 3-column translation format instead of the new 2-column one`.
+With it on, the second column will be unused and skipped during parsing.

 Example with Chinese translation:

@@ -386,6 +487,7 @@ Example with Chinese translation:
 ## List of translations
 - [🇨🇳 Chinese tags](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/discussions/23) by @HalfMAI, using machine translation and manual correction for the most common tags (uses legacy format)
 - [🇨🇳 Chinese tags](https://github.com/sgmklp/tag-for-autocompletion-with-translation) by @sgmklp, smaller set of manual translations based on https://github.com/zcyzcy88/TagTable
+- [🇯🇵 Japanese tags](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/discussions/265) by @applemango, both machine and human translations available

 > ### 🫵 I need your help!
 > Translations are a community effort. If you have translated a tag file or want to create one, please open a Pull Request or Issue so your link can be added here.
@@ -495,4 +597,4 @@ to force-reload the site without cache if e.g. a new feature doesn't appear for
 [multidiffusion-url]: https://github.com/pkuliyi2015/multidiffusion-upscaler-for-automatic1111
 [tag-editor-url]: https://github.com/toshiaki1729/stable-diffusion-webui-dataset-tag-editor
 [wd-tagger-url]: https://github.com/toriato/stable-diffusion-webui-wd14-tagger
-[umi-url]: https://github.com/Klokinator/Umi-AI
+[umi-url]: https://github.com/Klokinator/Umi-AI
--- a/README_JA.md
+++ b/README_JA.md
@@ -1,21 +1,67 @@
 ![tag_autocomplete_light](https://user-images.githubusercontent.com/34448969/208306863-90bbd663-2cb4-47f1-a7fe-7b662a7b95e2.png)

-# Booru tag autocompletion for A1111
+<div align="center">

-[![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/DominikDoom/a1111-sd-webui-tagcomplete)](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/releases)
+# SD WebUI Tag Autocomplete
+## [English Document](./README.md), [中文文档](./README_ZH.md), 日本語

-## [English Document](./README.md), [中文文档](./README_ZH.md)
+Booruスタイルタグを自動補完するためのAUTOMATIC1111 Stable Diffusion WebUI用拡張機能

-このカスタムスクリプトは、Stable Diffusion向けの人気のweb UIである、[AUTOMATIC1111 web UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui)の拡張機能として利用できます。
+[![Github Release][release-shield]][release-url]
+[![stargazers][stargazers-shield]][stargazers-url]
+[![contributors][contributors-shield]][contributors-url]
+[![forks][forks-shield]][forks-url]
+[![issues][issues-shield]][issues-url]
+
+[変更内容][release-url] •
+[確認されている問題](#%EF%B8%8F-よくある問題また現在確認されている問題) •
+[バグを報告する][issues-url] •
+[機能追加に関する要望][issues-url]
+</div>
+<br/>
+
+# 📄 説明
+
+Tag AutocompleteはStable Diffusion向けの人気のweb UIである、[AUTOMATIC1111 web UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui)の拡張機能として利用できます。

 主にアニメ系イラストを閲覧するための掲示板「Danbooru」などで利用されているタグの自動補完ヒントを表示するための拡張機能となります。  
-[Waifu Diffusion](https://github.com/harubaru/waifu-diffusion)など、この情報を使って学習させたStable Diffusionモデルもあるため、正確なタグをプロンプトに使用することで、構図を改善し、思い通りの画像が生成できるようになります。
+例えば[Waifu Diffusion](https://github.com/harubaru/waifu-diffusion)やNAIから派生した多くのモデルやマージなど、Stable Diffusionモデルの中にはこの情報を使って学習されたものもあるため、プロンプトに正確なタグを使用することで、多くのケースで構図を改善した思い通りの画像が生成できるようになります。

-web UIに内蔵されている利用可能な拡張機能リストを使用してインストールするか、[以下の説明](#インストール)に従ってファイルを手動でcloneするか、または[リリース](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/releases)からパッケージ化されたバージョンを使用することができます。
+組み込みの利用可能な拡張機能リストを使ってインストールしたり、[下記](#-インストール)の説明に従って手動でファイルをcloneしたり、[Releases](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/releases)にあるパッケージ済みのバージョンを使うことができます。

-## よく発生する問題 & 発見されている課題:
- ブラウザの設定によっては、古いバージョンのスクリプトがキャッシュされていることがあります。アップデート後に新機能が表示されない場合などには、`CTRL+F5`でキャッシュを利用せずにサイトを強制的にリロードしてみてください。
- プロンプトのポップアップのスタイルが崩れていたり、全く表示されない場合（[このような場合](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/7bbfdd54-fc23-4bfc-85af-24704b139b3a)）、openpose-editor拡張機能をインストールしている場合は、必ずアップデートしてください。古いバージョンでは、他の拡張機能との間で問題が発生することが知られています。
+<br/>
+
+# ✨ Features
+- 🚀 タイピング中に補完のためのヒントを表示 (通常時)
+- ⌨️ キーボードナビゲーション
+- 🌒 ダーク＆ライトモードのサポート
+- 🛠️ 多くの[設定](#%EF%B8%8F-設定)とカスタマイズ性を提供
+- 🌍 [翻訳サポート](#翻訳)タグ、オプションでプロンプトのライブ プレビュー付き
+   - 私が知っている翻訳のリストは[こちら](#翻訳リスト)を参照してください。
+
+タグの自動補完は組み込まれている補完内容をサポートしています：
+- 🏷️ **Danbooru & e621 tags** (投稿数上位100k、2022年11月現在)
+- ✳️ [**ワイルドカード**](#ワイルドカード)
+- ➕ [**Extra networks**](#extra-networks-embeddings-hypernets-lora-) filenames, including
+   - Textual Inversion embeddings
+   - Hypernetworks
+   - LoRA
+   - LyCORIS / LoHA
+- 🪄 [**Chants（詠唱）**](#chants詠唱) (長いプロンプトプリセット用のカスタムフォーマット)
+- 🏷️ "[**Extra file**](#extra-file)", カスタマイズ可能なextra tagsセット
+
+
+さらに、サードパーティの拡張機能にも対応しています：
+<details>
+<summary>クリックして開く</summary>
+
+- [Image Browser][image-browser-url] - ファイル名とEXIFキーワードによる検索
+- [Multidiffusion Upscaler][multidiffusion-url] - 地域別のプロンプト
+- [Dataset Tag Editor][tag-editor-url] - キャプション, 結果の確認, タグの編集 & キャプションの編集
+- [WD 1.4 Tagger][wd-tagger-url] - 追加と除外タグ
+- [Umi AI][umi-url] - YAMLワイルドカードの補完
+</details>
+<br/>

 ## スクリーンショット & デモ動画
 <details>
@@ -34,8 +80,8 @@ https://user-images.githubusercontent.com/34448969/200128031-22dd7c33-71d1-464f-
 ![results_light](https://user-images.githubusercontent.com/34448969/200128217-bfac8b60-6673-447b-90fd-dc6326f1618c.png)
 </details>

-## インストール
-### 内蔵されている拡張機能リストを用いた方法
+# 📦 インストール
+## 内蔵されている拡張機能リストを用いた方法
 1. Extensions タブを開く
 2. Available タブを開く
 3. "Load from:" をクリック
@@ -48,14 +94,14 @@ https://user-images.githubusercontent.com/34448969/200128031-22dd7c33-71d1-464f-
 ![Install](https://user-images.githubusercontent.com/34448969/223537336-5c02ccb1-233d-4e0d-9e73-d1b889252c49.png)


-### 手動でcloneする方法
+## 手動でcloneする方法
 ```bash
 git clone "https://github.com/DominikDoom/a1111-sd-webui-tagcomplete.git" extensions/tag-autocomplete
 ```
 （第2引数でフォルダ名を指定可能なので、好きな名前を指定しても良いでしょう）

-## 追加で有効化できる補完機能
-### ワイルドカード
+# ❇️ 追加で有効化できる補完機能
+## ワイルドカード

 自動補完は、https://github.com/AUTOMATIC1111/stable-diffusion-webui-wildcards 、または他の類似のスクリプト/拡張機能で使用されるワイルドカードファイルでも利用可能です。補完は `__` (ダブルアンダースコア) と入力することで開始されます。最初にワイルドカードファイルのリストが表示され、1つを選択すると、そのファイル内の置換オプションが表示されます。
 これにより、スクリプトによって置換されるカテゴリを挿入するか、または直接1つを選択して、ワイルドカードをカテゴリ化されたカスタムタグシステムのようなものとして使用することができます。
@@ -66,20 +112,21 @@ git clone "https://github.com/DominikDoom/a1111-sd-webui-tagcomplete.git" extens

 ワイルドカードはすべての拡張機能フォルダと、古いバージョンをサポートするための `scripts/wildcards` フォルダで検索されます。これは複数の拡張機能からワイルドカードを組み合わせることができることを意味しています。ワイルドカードをグループ化した場合、ネストされたフォルダもサポートされます。

-### Embeddings, Lora & Hypernets
+## Extra networks (Embeddings, Hypernets, LoRA, ...)
 これら3つのタイプの補完は、`<`と入力することで行われます。デフォルトでは3つとも混在して表示されますが、以下の方法でさらにフィルタリングを行うことができます：
 - `<e:` は、embeddingsのみを表示します。
- `<l:` 、または `<lora:` はLoraのみを表示します。
+- `<l:` は、LoRAとLyCORISのみを表示します。
+  - または `<lora:` と　`<lyco:` で入力することも可能です
 - `<h:` 、または `<hypernet:` はHypernetworksのみを表示します

-#### Embedding type filtering
+### Embedding type filtering
 Stable Diffusion 1.xまたは2.xモデル用にそれぞれトレーニングされたembeddingsは、他のタイプとの互換性がありません。有効なembeddingsを見つけやすくするため、若干の色の違いも含めて「v1 Embedding」と「v2 Embedding」で分類しています。また、`<v1/2`または`<e:v1/2`に続けて実際の検索のためのキーワードを入力すると、v1またはv2embeddingsのみを含むように検索を絞り込むことができます。

 例:

 ![Embedding version filter](https://user-images.githubusercontent.com/34448969/223533883-d99c04b7-a199-4f56-a4e5-242eee9726a2.png)

-### Chants（詠唱）
+## Chants（詠唱）
 Chants（詠唱）は、より長いプロンプトプリセットです。この名前は、中国のユーザーによる初期のプロンプト集からヒントを得たもので、しばしば「呪文書」（原文は「Spellbook」「Codex」）などと呼ばれていました。  
 このような文書から得られるプロンプトのスニペットは、このような理由から呪文や詠唱と呼ばれるにふさわしいものでした。

@@ -89,8 +136,11 @@ EmbeddingsやLoraと同様に、この機能は `<`, `<c:`, `<chant:` コマン
 (masterpiece, best quality, high quality, highres, ultra-detailed),
 ```

-
 Chants（詠唱）は、以下のフォーマットに従ってJSONファイルで追加することができます：:
+
+<details>
+<summary>Chant format (click to expand)</summary>
+
 ```json
 [
    {
@@ -113,6 +163,10 @@ Chants（詠唱）は、以下のフォーマットに従ってJSONファイル
    }
 ]
 ```
+
+</details>
+<br/>
+
 このファイルが拡張機能の `tags` フォルダ内にある場合、settings内の"Chant file"ドロップダウンから選択することができます。

 chantオブジェクトは4つのフィールドを持ちます：
@@ -121,7 +175,7 @@ chantオブジェクトは4つのフィールドを持ちます：
 - `content` - 実際に挿入されるプロンプト
 - `color` - 表示される色。通常のタグと同じカテゴリーカラーシステムを使用しています。

-### Umi AI tags
+## Umi AI tags
 https://github.com/Klokinator/Umi-AI は、Unprompted や Dynamic Wildcards に似た、機能豊富なワイルドカード拡張です。  
 例えば `<[preset][--female][sfw][species]>` はプリセットカテゴリーを選び、女性関連のタグを除外し、さらに次のカテゴリーで絞り込み、実行時にこれらすべての条件に一致するランダムなフィルインを1つ選び出します。補完は `<[`] とそれに続く新しい開く括弧、例えば `<[xyz][`] で始まり、 `>` で閉じるまで続きます。

@@ -130,78 +184,264 @@ https://github.com/Klokinator/Umi-AI は、Unprompted や Dynamic Wildcards に

 ほとんどの功績は[@ctwrs](https://github.com/ctwrs)によるものです。この方はUmiの開発者の一人として多くの貢献をしています。

-## Settings
+# 🛠️ 設定

-この拡張機能には、大量の設定＆カスタマイズ性が組み込まれています:
+この拡張機能には多くの設定とカスタマイズ機能が組み込まれています。ほとんどのことははっきりしていますが、詳細な説明は以下のセクションをクリックしてください。

-![image](https://user-images.githubusercontent.com/34448969/204093162-99c6a0e7-8183-4f47-963b-1f172774f527.png)
+<!-- Filename -->
+<details>
+<summary>Tag filename</summary>

-| 設定項目	| 説明 |
-|---------|-------------|
-| tagFile | 使用するタグファイルを指定します。お好みのタグデータベースを用意することができますが、このスクリプトはDanbooruタグを想定して開発されているため、他の構成では正常に動作しない場合があります。|
-| activeIn | txt2img、img2img、またはその両方のネガティブプロンプトのスクリプトを有効、または無効にすることができます。 |
-| maxResults | 最大何件の結果を表示するか。デフォルトのタグセットでは、結果は出現回数順に表示されます。embeddingsとワイルドカードの場合は、スクロール可能なリストですべての結果を表示します。 |
-| resultStepLength | 長いリストやshowAllResultsがtrueの場合に、指定したサイズの小さなバッチで結果を読み込むことができるようにします。 |
-| delayTime | オートコンプリートを起動するまでの待ち時間をミリ秒単位で指定できます。これは入力中に頻繁に補完内容が更新されるのを防ぐのに役立ちます。 |
-| showAllResults | trueの場合、maxResultsを無視し、すべての結果をスクロール可能なリストで表示します。**警告:** 長いリストの場合、ブラウザが遅くなることがあります。 |
-| replaceUnderscores | trueにした場合、タグをクリックしたときに `_`（アンダースコア）が ` `（スペース）に置き換えられます。モデルによっては便利になるかもしれません。 |
-| escapeParentheses | trueの場合、()を含むタグをエスケープして、Web UIのプロンプトの重み付け機能に影響を与えないようにします。 |
-| appendComma | UIスイッチ "Append commas"の開始される値を指定することができます。UIのオプションが無効の場合、常にこの値が使用されます。 |
-| useWildcards | ワイルドカード補完機能の切り替えに使用します。 |
-| useEmbeddings | embedding補完機能の切り替えに使用します。 |
-| alias | エイリアスに関するオプションです。詳しくは下のセクションをご覧ください。 |
-| translation | 翻訳用のオプションです。詳しくは下のセクションをご覧ください。 |
-| extras | タグファイル/エイリアス/翻訳を追加するためのオプションです。詳しくは下記をご覧ください。 |
-| chantFile | chants（長いプロンプト・プリセット/ショートカット）に使用するためファイルです。 |
-| keymap | カスタマイズ可能なhotkeyを設定するために利用します。 |
-| colors | タグの色をカスタマイズできます。詳しくは下記をご覧ください。 |
-### Colors
-タグタイプに関する色は、タグ自動補完設定のためのJSONコードを変更することで指定することができます。  
-フォーマットは標準的なJSONで、オブジェクト名は、それらが使用されるタグのファイル名（.csvを除く）に対応しています。  
-角括弧の中の最初の値はダークモード、2番目の値はライトモードです。色の名称と16進数、どちらも使えるはずです。
+スクリプトが使用するメインのタグファイルとなります。デフォルトでは `danbooru.csv` と `e621.csv` が含まれており、ここにカスタムタグを追加することもできますが、大半のモデルはこの2つ以外（主にdanbooru）では学習していないため、あまり意味はありません。

-```json
-{
-	"danbooru": {
-		"-1": ["red", "maroon"],
-		"0": ["lightblue", "dodgerblue"],
-		"1": ["indianred", "firebrick"],
-		"3": ["violet", "darkorchid"],
-		"4": ["lightgreen", "darkgreen"],
-		"5": ["orange", "darkorange"]
-	},
-	"e621": {
-		"-1": ["red", "maroon"],
-		"0": ["lightblue", "dodgerblue"],
-		"1": ["gold", "goldenrod"],
-		"3": ["violet", "darkorchid"],
-		"4": ["lightgreen", "darkgreen"],
-		"5": ["tomato", "darksalmon"],
-		"6": ["red", "maroon"],
-		"7": ["whitesmoke", "black"],
-		"8": ["seagreen", "darkseagreen"]
-	}
-}
-```
-また、カスタムタグファイルの新しいカラーセットを追加する際にも使用できます。
-数字はタグの種類を指定するもので、タグのソースに依存します。例として、[CSV tag data](#csv-tag-data)を参照してください。
+拡張機能の他の機能（ワイルドカードやLoRA補完など）を使いたいが、通常のタグには興味がない場合は、`None`に設定することも可能です。

-### エイリアス, 翻訳 & Extra tagsについて
-#### エイリアス
-Booruのサイトのように、タグは1つまたは複数のエイリアスを持つことができ、完了時に実際の値へリダイレクトされて入力されます。これらは `config.json` の設定をもとに検索/表示されます：
- `searchByAlias` - エイリアスも検索対象とするか、実際のタグのみを検索対象とするかを設定します
- `onlyShowAlias` - `alias -> actual` の代わりに、エイリアスのみを表示します。表示のみで、最後に挿入されるテキストは実際のタグのままです。
+![tagfile](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/2b37c581-aeb1-4642-b0a4-c93c4c059a7a)
+</details>

-#### 翻訳
+<!-- Active In -->
+<details>
+<summary>"Active in" の設定</summary>
+
+タグのオートコンプリートがどこにアタッチされ、変更を受け付けるかを指定します。
+ネガティブプロンプトはtxt2imgとimg2imgの設定に従うので、"親 "がアクティブな場合にのみアクティブとなります。
+
+![activeIn](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/936538c9-2ed0-4254-8e91-9f2ed1af0ccf)
+</details>
+
+<!-- Blacklist -->
+<details>
+<summary>Black / Whitelist</summary>
+
+このオプションは、タグのオートコンプリートをグローバルにオフにすることができますが、特定のモデルに対してのみ有効または無効にしたい場合もあります。  
+例えば、あなたのモデルのほとんどがアニメモデルである場合、boorタグでトレーニングされておらず、その恩恵を受けないフォトリアリスティックモデルをブラックリストに追加し、これらのモデルに切り替えた後に自動的に無効にすることができます。モデル名(拡張子を含む)とwebuiハッシュ(短い形式と長い形式の両方)の両方を使用できます。
+
+`Blacklist`は指定したすべてのモデルを除外しますが、`Whitelist`はこれらのモデルに対してのみ有効で、デフォルトではオフのままです。例外として、空のホワイトリストは無視されます（空のブラックリストと同じです）。
+
+![blacklist](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/13e46ce5-fe6d-4d15-98ac-cfe30ca419e9)
+</details>
+<!-- Move Popup -->
+<details>
+<summary>カーソルで補完ポップアップを移動</summary>
+
+このオプションは、IDEで行われるような、カーソルの位置に追従するフローティングポップアップを有効または無効にします。スクリプトはポップアップが右側でつぶれないように十分なスペースを確保しようとしますが、長いタグでは必ずしもうまくいきません。無効にした場合、ポップアップは左側に表示されます。
+
+![movePopup](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/26e6050f-a70e-49a3-add0-2b58cdef37a2)
+	
+![movePopup_on](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/f10a3c16-ce49-4bdb-a106-2810d5343bd7)
+![movePopup_off](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/469f0a79-3839-4ad2-8dc0-4a1298ffff05)
+</details>
+<!-- Results Count -->
+<details>
+<summary>結果の数</summary>
+
+一度に表示する結果の量を設定できます。  
+`Show all results`が有効な場合、`Maximum results`で指定された数で切り捨てられるのではなく、スクロール可能なリストが表示されます。パフォーマンス上の理由から、この場合はすべてを一度に読み込むのではなく、ブロック単位で読み込みます。ブロックの大きさは`How many results to load at once`によって決まります。一番下に到達すると、次のブロックがロードされます（しかし、そんなことはめったには起こらないと思います）。
+
+特筆すべきこととして、`Show all results` が使用される場合でも、`Maximum results` は影響を及ぼします。これは、スクロールが開始される前のポップアップの高さを制限するからです。
+
+![resultsCount](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/f9ffeb4b-6c82-48ed-a204-f4658e335f7e)
+</details>
+<!-- Delay time -->
+<details>
+<summary>補完の遅れについて</summary>
+
+設定によっては、リアルタイムのタグ補完は計算量が多くなることがあります。  
+このオプションは debounce による遅延をミリ秒単位で設定します（1000ミリ秒 = 1秒）。このオプションは、入力が非常に速い場合に特に有効です。
+
+![delay](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/d1718dc1-32c3-4075-80aa-b6caebcafa05)
+</details>
+<!-- Search for -->
+<details>
+<summary>"Search for" に関する設定</summary>
+
+特定の補完タイプを有効または無効にします。
+
+Umi AIワイルドカードは、使用目的が似ているため、異なるフォーマットを使用しますが、ここでは通常のワイルドカードオプションに含まれます。
+
+![searchFor](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/9e7c27eb-68fb-47cd-a7c7-333476374c58)
+</details>
+<!-- Wiki links -->
+<details>
+<summary>"?" Wiki links</summary>
+
+このオプションがオンになっている場合、タグの横に `?` リンクが表示されます。これをクリックすると、danbooruまたはe621のそのタグのWikiページを開こうとします。
+
+> ⚠️ 警告：
+>
+> Danbooruとe621は外部サイトであり、多くのNSFWコンテンツを含んでいます。このため、このオプションはデフォルトで無効になっています。
+
+![wikiLink](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/733e1ba8-89e1-4c2b-8c4e-2d23352bd3d7)
+</details>
+<!-- Insertion -->
+<details>
+<summary>補完設定</summary>
+
+これらの設定で、テキストの挿入方法を指定できます。
+
+Booruのサイトでは、タグにスペースの代わりにアンダースコアを使用することがほとんどですが、Stable diffusionで使用されているCLIPエンコーダーは自然言語でトレーニングされているため、前処理中にほとんどのモデルがこのアンダースコアをスペースに置き換えました。したがって、デフォルトではタグのオートコンプリートも同じようになります。
+
+括弧は、プロンプトの特定の部分をより注目/重視するために、Webuiの制御文字として使用されるため、デフォルトでは括弧を含むタグはエスケープされます (`\( \)`) 。
+
+最後の設定によりますが、タグのオートコンプリートはタグを挿入した後にカンマとスペースを追加します。
+
+![insertEscape](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/d28557be-6c75-43fd-bf17-c0609223b384)
+</details>
+<!-- Wildcard path mode -->
+<details>
+<summary>ワイルドカードのパス補完</summary>
+
+ワイルドカードのいくつかのコレクションは、ネストしたサブフォルダに整理されています。  
+それらは、"hair/colors/light/... " や "clothing/male/casual/... " などのように、ファイルへのフルパスとともにリストアップされています。
+
+このような場合、手動でフルパスを入力するのは難しいことが多いのですが、それでもリストをさらにスクロールする前に選択範囲を狭めたいものです。  
+この場合、選択する結果がすべてのパスであれば、<kbd>Tab</kbd>（または`ChooseSelectedOrFirst`のカスタムホットキー）でパスの部分補完をトリガーすることが可能です。
+
+この設定は、補完に使用するモードを決定します:
+- 次のフォルダレベルまで:
+   - パス内の次の/まで補完し、選択したものを進む方向として優先します
+   - オプションを直接選択したい場合は、<kbd>Enter</kbd> キーまたは `ChooseSelected` ホットキーを使用してスキップし、完全に補完します。
+- 最初の差分まで:
+   - 結果内の最初の違いまで補完し、追加の情報を待ちます
+   - 例："/sub/folder_a/..." と "/sub/folder_b/..." がある場合、"su" と入力した後に補完すると、"/sub/folder_" まですべてを挿入し、a または b を入力して明確にするまでそこで停止します。
+   - 矢印キーで何かを選択した場合（EnterキーやTabキーを押すかどうかに関係なく）、それをスキップして完全に補完します。
+- 常に全て:
+   - 名前が示すように、部分的な補完動作を無効にし、通常のタグのようにすべての状況下で完全なパスを挿入します。
+
+![insertWildcardPath](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/ed354bd1-3f23-4fb1-a638-ac3b7a213fc5)
+</details>
+<!-- Alias -->
+<details>
+<summary>Alias 設定</summary>
+
+タグはしばしば複数の別名(Alias)で参照されます。`Search by alias`がオンになっている場合、それらは検索結果に含まれ、正しいタグがわからない場合に役立ちます。この場合でも、挿入時にリンクされている実際のタグに置き換えられます。
+
+`Only show alias` セットは、エイリアスのみを表示したい場合、またはそのエイリアスがマップするタグも表示したい場合に使用します。
+(`<alias> ➝ <actual>`として表示されます)
+
+![alias](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/f2087510-67cf-448d-88f7-81eb677412b5)
+</details>
+<!-- Translations -->
+<details>
+<summary>翻訳設定</summary>
+
+Tag Autocompleteは、別のファイル（`Translation filename`）で指定されたタグの翻訳をサポートしています。つまり、英語のタグ名が分からなくても、自身の言語の翻訳ファイルがあれば、それを代わりに使うことができます。
+
+また、コミュニティで使用されている古いファイルのためのレガシーフォーマットオプションや、プロンプト全体のライブ翻訳プレビューなど実験的な機能もあります。
+
+詳細については、以下の [翻訳に関するセクション](#翻訳) を参照してください。
+
+![translation](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/a860c5dc-7428-46ac-a8a8-5d1b2b773a60)
+</details>
+<!-- Extra file -->
+<details>
+<summary>Extra ファイル設定</summary>
+
+ここで指定したように、通常の結果の前後に追加される追加タグのセットを指定します。一般的に使用される品質タグ (`masterpiece, best quality,` など) のような小さなカスタムタグセットに便利です。
+
+長いプリセットやプロンプト全体を補完したい場合は、代わりに [Chants（詠唱）](#chants詠唱) を参照してください。
+
+![extraFile](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/14c28af2-b3cb-42b1-a13e-ee0c688a4a5d)
+</details>
+<!-- Chants -->
+<details>
+<summary>Chant ファイル名</summary>
+
+Chantとは、長いプリセット、あるいはプロンプト全体を一度に選択して挿入できるもので、Webuiに内蔵されているスタイルのドロップダウンに似ています。Chantにはいくつかの追加機能があり、より速く使用することができます。
+
+詳しくは上記の[Chants（詠唱）](#chants詠唱)のセクションを参照してください。
+	
+![chants](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/e8045d41-a776-49b3-8298-c879097661a4)
+</details>
+<!-- Hotkeys -->
+<details>
+<summary>Hotkeys</summary>
+
+ほとんどのキーボードナビゲーション機能のホットキーをここで指定できます。  
+https://www.w3.org/TR/uievents-key/#named-key-attribute-value
+
+機能の説明
+- Move Up / Down：次のタグを選択
+- Jump Up / Down：一度に5箇所移動する。
+- Jump to Start / End： リストの先頭または末尾にジャンプ
+- ChooseSelected ハイライトされたタグを選択するか、何も選択されていない場合はポップアップを閉じます。
+- ChooseSelectedOrFirst:上記と同じですが、何も選択されていない場合、デフォルトで最初の結果が選択されます。
+- Close ポップアップを閉じる
+
+![hotkeys](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/7e9bafd7-d5bd-4e1f-a1eb-f08bebba1423)
+</details>
+<!-- Colors -->
+<details>
+<summary>Colors</summary>
+
+ここでは、異なるタグカテゴリーに使用されるデフォルトの色を変更することができます。これらは、ソースサイトのカテゴリの色に似ているように選択されています。
+
+フォーマットは標準的なJSON
+- オブジェクト名は、タグのファイル名に対応しています。
+- 数字はタグの種類を表し、タグのソースに依存します。詳細については、[CSV tag data](#csv-tag-data)を参照してください。
+- 角括弧内の最初の値はダークモード、2番目の値はライトモードです。HTMLの色名と16進数コードのどちらでも使えます。
+
+これは、カスタムタグ・ファイルに新しいカラーセットを追加するためにも使用できます。
+	
+![colors](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/b9b66d8d-5619-4bd3-bdb6-053a01540d71)
+</details>
+<!-- Temp files refresh -->
+<details>
+<summary>TACの一時作成ファイルのリフレッシュ</summary>
+
+これは "フェイク"設定で、実際には何も設定しません。むしろ、開発者がwebuiのオプションに追加できる更新ボタンを悪用するための小さなハックです。この設定の隣にある更新ボタンをクリックすると、タグオートコンプリートにいくつかの一時的な内部ファイルを再作成・再読み込みさせます。
+
+タグオートコンプリートは様々な機能、特に余分なネットワークとワイルドカード補完に関連するこれらのファイルに依存しています。この設定は、例えば新しいLoRAをいくつかフォルダに追加し、タグ・オートコンプリートにリストを表示させるためにUIを再起動したくない場合に、リストを再構築するために使用できます。
+
+また、この設定をクイック設定バーに追加することで、いつでも更新ボタンを利用できるようになります。
+
+![fakeRefresh](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/9eb87446-a635-4623-89b5-a76ab39e879a)
+</details>
+<br/>
+
+# 翻訳
 タグとエイリアスの両方を翻訳するために使用することができ、また翻訳による検索を可能にするための、追加のファイルを翻訳セクションに追加することができます。  
-このファイルは、`<英語のタグ/エイリアス>,<翻訳>`という形式のCSVである必要がありますが、3列のフォーマットを使用する古いファイルとの後方互換性のために、`oldFormat`をオンにすると代わりにそれを使うことができます。
+このファイルは、`<English tag/alias>,<Translation>`という形式のCSVである必要がありますが、3列のフォーマットを使用する古いファイルとの後方互換性のために、`oldFormat`をオンにすると、代わりに新しい2列の翻訳形式ではなく、古い3列の翻訳形式を使用するようになります。  
+その場合、2番目のカラムは使用されず、パース時にスキップされます。

 中国語の翻訳例：

 ![IME-input](https://user-images.githubusercontent.com/34448969/200126551-2264e9cc-abb2-4450-9afa-43f362a77ab0.png)
 ![english-input](https://user-images.githubusercontent.com/34448969/200126513-bf6b3940-6e22-41b0-a369-f2b4640f87d6.png)

-#### Extra file
+## 翻訳リスト
+- [🇨🇳 中国語訳](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/discussions/23) by @HalfMAI, 最も一般的なタグを機械翻訳と手作業で修正（レガシーフォーマットを使用）
+- [🇨🇳 中国語訳](https://github.com/sgmklp/tag-for-autocompletion-with-translation) by @sgmklp, [こちら](https://github.com/zcyzcy88/TagTable)をベースにして、より小さくした手動での翻訳セット。
+- [🇯🇵 日本語訳](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/discussions/265) by @applemango, 機械翻訳と人力翻訳の両方が利用可能。
+
+> ### 🫵 あなたの助けが必要です！
+> 翻訳はコミュニティの努力により支えられています。もしあなたがタグファイルを翻訳したことがある場合、または作成したい場合は、あなたの成果をここに追加できるように、Pull RequestまたはIssueを開いてください。
+> 機械翻訳は、最も一般的なタグであっても、多くのことを間違えてしまいます。
+
+## ライブ・プレビュー
+> ⚠️ 警告:
+>
+> この機能はまだ実験的なもので、使用中にバグに遭遇するかもしれません。
+
+この機能はプロンプト内のすべての検出されたタグのライブプレビューを表示します。検出されたタグは、カンマで正しく区切られたものと長い文章の中にあるものの両方が表示されます。自然な文章では3単語まで検出することができ、1つのタグよりも複数単語の完全な一致を優先します。
+
+検出されたタグの上には翻訳ファイルからの訳文が表示されるので、英語のタグの意味がよく分からない場合でも、プロンプトにタグが挿入された後でも（完了時のポップアップではなく）簡単に見つけることができます。
+
+このオプションはデフォルトではオフになっていますが、翻訳ファイルを選択し、「Show live tag translation below prompt」をチェックすることで有効にすることができます。
+オフでも通常の機能には影響しません。
+
+中国語翻訳時の例:
+
+![image](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/bbc0b860-78f6-498f-91f9-33cf840716f7)
+
+検出されたタグをクリックすると、そのタグがプロンプトで選択され、素早く編集できます。
+
+![image](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/c6380106-e1e2-4da9-a819-7808ff30e8f5)
+
+#### ⚠️ ライブ翻訳に関する確認されている問題：
+ユーザーがテキストを入力または貼り付けると翻訳が更新されますが、プログラムによる操作（スタイルの適用やPNG Info / Image Browserからの読み込みなど）では更新されません。これは、プログラムによる編集の後に手動で何かを入力することで回避できます。
+
+# Extra file
 エクストラファイルは、メインセットに含まれない新しいタグやカスタムタグを追加するために使用されます。  
 [CSV tag data](#csv-tag-data)にある通常のタグのフォーマットと同じですが、ひとつだけ例外があります：
 カスタムタグにはカウントがないため、3列目（0から数える場合は2列目）はタグの横に表示される灰色のメタテキストに使用されます。
@@ -213,7 +453,7 @@ Booruのサイトのように、タグは1つまたは複数のエイリアス

 カスタムタグを通常のタグの前に追加するか、後に追加するかは、設定で選択することができます。

-## CSV tag data
+# CSV tag data
 このスクリプトは、以下の方法で保存されたタグ付きCSVファイルを想定しています:
 ```csv
 <name>,<type>,<postCount>,"<aliases>"
@@ -252,3 +492,32 @@ commentary_request,5,2610959,
 |8	| Lore        |

 タグの種類は、結果の一覧のエントリーの色付けに使用されます。
+
+## ⚠️ よくある問題、また現在確認されている問題:
+- お使いのブラウザの設定によっては、古いバージョンのスクリプトがキャッシュされることがあります。例えば、アップデート後に新機能が表示されない場合は、キャッシュを使わずにサイトを強制的にリロードするために、
+<kbd>CTRL</kbd> + <kbd>F5</kbd>
+を試してください。
+- プロンプトのポップアップが壊れたスタイルで表示されるか、全く表示されない場合（[このような場合](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/7bbfdd54-fc23-4bfc-85af-24704b139b3a)）、openpose-editor 拡張機能がインストールされている場合は更新してください。古いバージョンでは他の拡張機能との間で問題が生じることが知られています。
+
+<!-- Variable declarations for shorter main text -->
+[release-shield]: https://img.shields.io/github/v/release/DominikDoom/a1111-sd-webui-tagcomplete?logo=github&style=
+[release-url]: https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/releases
+
+[contributors-shield]: https://img.shields.io/github/contributors/DominikDoom/a1111-sd-webui-tagcomplete
+[contributors-url]: https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/graphs/contributors
+
+[forks-shield]: https://img.shields.io/github/forks/DominikDoom/a1111-sd-webui-tagcomplete
+[forks-url]: https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/network/members
+
+[stargazers-shield]: https://img.shields.io/github/stars/DominikDoom/a1111-sd-webui-tagcomplete
+[stargazers-url]: https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/stargazers
+
+[issues-shield]: https://img.shields.io/github/issues/DominikDoom/a1111-sd-webui-tagcomplete
+[issues-url]: https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/issues/new/choose
+
+<!-- Links for feature section -->
+[image-browser-url]: https://github.com/AlUlkesh/stable-diffusion-webui-images-browser
+[multidiffusion-url]: https://github.com/pkuliyi2015/multidiffusion-upscaler-for-automatic1111
+[tag-editor-url]: https://github.com/toshiaki1729/stable-diffusion-webui-dataset-tag-editor
+[wd-tagger-url]: https://github.com/toriato/stable-diffusion-webui-wd14-tagger
+[umi-url]: https://github.com/Klokinator/Umi-AI
--- a/README_ZH.md
+++ b/README_ZH.md
@@ -13,6 +13,12 @@
 你可以按照[以下方法](#installation)下载或拷贝文件，也可以使用[Releases](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/releases)中打包好的文件。

 ## 常见问题 & 已知缺陷:
+- 很多中国用户都报告过此扩展名和其他扩展名的 JavaScript 文件被阻止的问题。
+常见的罪魁祸首是 IDM / Internet Download Manager 浏览器插件，它似乎出于安全目的阻止了本地文件请求。
+如果您安装了 IDM，请确保在使用 webui 时禁用以下插件：
+
+    ![image](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/assets/34448969/d253a4a9-71ab-4b5f-80c4-5aa926fc1fc9)
+
 - 当`replaceUnderscores`选项开启时, 脚本只会替换Tag的一部分如果Tag包含多个单词,比如将`atago (azur lane)`修改`atago`为`taihou`并使用自动补全时.会得到 `taihou (azur lane), lane)`的结果, 因为脚本没有把后面的部分认为成同一个Tag。

 ## 演示与截图
--- a/javascript/__globals.js
+++ b/javascript/__globals.js
@@ -1,53 +1,204 @@
-// Core components
-var TAC_CFG = null;
-var tagBasePath = "";
+// Create our TAC namespace
+var TAC = TAC || {};

-// Tag completion data loaded from files
-var allTags = [];
-var translations = new Map();
-var extras = [];
-// Same for tag-likes
-var wildcardFiles = [];
-var wildcardExtFiles = [];
-var yamlWildcards = [];
-var embeddings = [];
-var hypernetworks = [];
-var loras = [];
-var lycos = [];
-var chants = [];
+/**
+ * @typedef {Object} TAC.CFG
+ * @property {string} tagFile - Tag filename
+ * @property {{ global: boolean, txt2img: boolean, img2img: boolean, negativePrompts: boolean, thirdParty: boolean, modelList: string, modelListMode: "Blacklist"|"Whitelist" }} activeIn - Settings for which parts of the UI the tag completion is active in.
+ * @property {boolean} slidingPopup - Move completion popup together with text cursor
+ * @property {number} maxResults - Maximum results
+ * @property {boolean} showAllResults - Show all results
+ * @property {number} resultStepLength - How many results to load at once
+ * @property {number} delayTime - Time in ms to wait before triggering completion again
+ * @property {boolean} useWildcards - Search for wildcards
+ * @property {boolean} sortWildcardResults - Sort wildcard file contents alphabetically
+ * @property {boolean} useEmbeddings - Search for embeddings
+ * @property {boolean} includeEmbeddingsInNormalResults - Include embeddings in normal tag results
+ * @property {boolean} useHypernetworks - Search for hypernetworks
+ * @property {boolean} useLoras - Search for Loras
+ * @property {boolean} useLycos - Search for LyCORIS/LoHa
+ * @property {boolean} useLoraPrefixForLycos - Use the '<lora:' prefix instead of '<lyco:' for models in the LyCORIS folder
+ * @property {boolean} showWikiLinks - Show '?' next to tags, linking to its Danbooru or e621 wiki page
+ * @property {boolean} showExtraNetworkPreviews - Show preview thumbnails for extra networks if available
+ * @property {string} modelSortOrder - Model sort order
+ * @property {boolean} frequencySort - Locally record tag usage and sort frequent tags higher
+ * @property {string} frequencyFunction - Function to use for frequency sorting
+ * @property {number} frequencyMinCount - Minimum number of uses for a tag to be considered frequent
+ * @property {number} frequencyMaxAge - Maximum days since last use for a tag to be considered frequent
+ * @property {number} frequencyRecommendCap - Maximum number of recommended tags
+ * @property {boolean} frequencyIncludeAlias - Frequency sorting matches aliases for frequent tags
+ * @property {boolean} useStyleVars - Search for webui style names
+ * @property {boolean} replaceUnderscores - Replace underscores with spaces on insertion
+ * @property {string} replaceUnderscoresExclusionList - Underscore replacement exclusion list
+ * @property {boolean} escapeParentheses - Escape parentheses on insertion
+ * @property {boolean} appendComma - Append comma on tag autocompletion
+ * @property {boolean} appendSpace - Append space on tag autocompletion
+ * @property {boolean} alwaysSpaceAtEnd - Always append space if inserting at the end of the textbox
+ * @property {string} wildcardCompletionMode - How to complete nested wildcard paths
+ * @property {string} modelKeywordCompletion - Try to add known trigger words for LORA/LyCO models
+ * @property {string} modelKeywordLocation - Where to insert the trigger keyword
+ * @property {string} wcWrap - Wrapper characters for wildcard tags.
+ * @property {{ searchByAlias: boolean, onlyShowAlias: boolean }} alias - Alias-related settings.
+ * @property {{ translationFile: string, oldFormat: boolean, searchByTranslation: boolean, liveTranslation: boolean }} translation - Translation-related settings.
+ * @property {{ extraFile: string, addMode: "Insert before"|"Insert after" }} extra - Extra file-related settings.
+ * @property {string} chantFile - Chant filename
+ * @property {number} extraNetworksDefaultMultiplier - Default multiplier for extra networks.
+ * @property {string} extraNetworksSeparator - Separator used for extra networks.
+ * @property {{ MoveUp: string, MoveDown: string, JumpUp: string, JumpDown: string, JumpToStart: string, JumpToEnd: string, ChooseSelected: string, ChooseFirstOrSelected: string, Close: string }} keymap - Custom key mappings for tag completion.
+ * @property {{ [filename: string]: { [category: string]: string[] } }} colorMap - Color mapping for tag categories.
+ */
+/** @type {TAC.CFG}  */
+TAC.CFG = {
+    // Main tag file
+    tagFile: "",
+    // Active in settings
+    activeIn: {
+        global: true,
+        txt2img: true,
+        img2img: true,
+        negativePrompts: true,
+        thirdParty: true,
+        modelList: "",
+        modelListMode: "Blacklist",
+    },
+    // Results related settings
+    slidingPopup: true,
+    maxResults: 8,
+    showAllResults: false,
+    resultStepLength: 500,
+    delayTime: 100,
+    useWildcards: true,
+    sortWildcardResults: true,
+    useEmbeddings: true,
+    includeEmbeddingsInNormalResults: true,
+    useHypernetworks: true,
+    useLoras: true,
+    useLycos: true,
+    useLoraPrefixForLycos: true,
+    showWikiLinks: false,
+    showExtraNetworkPreviews: true,
+    modelSortOrder: "Name",
+    frequencySort: true,
+    frequencyFunction: "Logarithmic (weak)",
+    frequencyMinCount: 3,
+    frequencyMaxAge: 30,
+    frequencyRecommendCap: 10,
+    frequencyIncludeAlias: false,
+    useStyleVars: false,
+    // Insertion related settings
+    replaceUnderscores: true,
+    replaceUnderscoresExclusionList: "0_0,(o)_(o),+_+,+_-,._.,<o>_<o>,<|>_<|>,=_=,>_<,3_3,6_9,>_o,@_@,^_^,o_o,u_u,x_x,|_|,||_||",
+    escapeParentheses: true,
+    appendComma: true,
+    appendSpace: true,
+    alwaysSpaceAtEnd: true,
+    wildcardCompletionMode: "To next folder level",
+    modelKeywordCompletion: "Never",
+    modelKeywordLocation: "Start of prompt",
+    wcWrap: "__", // to support custom wrapper chars set by dp_parser
+    // Alias settings
+    alias: {
+        searchByAlias: true,
+        onlyShowAlias: false,
+    },
+    // Translation settings
+    translation: {
+        translationFile: "None",
+        oldFormat: false,
+        searchByTranslation: true,
+        liveTranslation: false,
+    },
+    // Extra file settings
+    extra: {
+        extraFile: "extra-quality-tags.csv",
+        addMode: "Insert before",
+    },
+    // Chant file settings
+    chantFile: "demo-chants.json",
+    // Settings not from tac but still used by the script
+    extraNetworksDefaultMultiplier: 1.0,
+    extraNetworksSeparator: ", ",
+    // Custom mapping settings
+    keymap: {
+        MoveUp: "ArrowUp",
+        MoveDown: "ArrowDown",
+        JumpUp: "PageUp",
+        JumpDown: "PageDown",
+        JumpToStart: "Home",
+        JumpToEnd: "End",
+        ChooseSelected: "Enter",
+        ChooseFirstOrSelected: "Tab",
+        Close: "Escape",
+    },
+    colorMap: {
+        filename: { category: ["light", "dark"] },
+    },
+};

-// Selected model info for black/whitelisting
-var currentModelHash = "";
-var currentModelName = "";
+TAC.Globals = new (function () {
+    // Core components
+    this.tagBasePath = "";
+    this.modelKeywordPath = "";
+    this.selfTrigger = false;

-// Current results
-var results = [];
-var resultCount = 0;
+    // Tag completion data loaded from files
+    this.allTags = [];
+    this.translations = new Map();
+    this.extras = [];
+    // Same for tag-likes
+    this.wildcardFiles = [];
+    this.wildcardExtFiles = [];
+    this.yamlWildcards = [];
+    this.umiWildcards = [];
+    this.embeddings = [];
+    this.hypernetworks = [];
+    this.loras = [];
+    this.lycos = [];
+    this.modelKeywordDict = new Map();
+    this.chants = [];
+    this.styleNames = [];

-// Relevant for parsing
-var previousTags = [];
-var tagword = "";
-var originalTagword = "";
-let hideBlocked = false;
+    // Selected model info for black/whitelisting
+    this.currentModelHash = "";
+    this.currentModelName = "";

-// Tag selection for keyboard navigation
-var selectedTag = null;
-var oldSelectedTag = null;
+    // Current results
+    this.results = [];
+    this.resultCount = 0;

-// UMI
-var umiPreviousTags = [];
+    // Relevant for parsing
+    this.previousTags = [];
+    this.tagword = "";
+    this.originalTagword = "";
+    this.hideBlocked = false;
+
+    // Tag selection for keyboard navigation
+    this.selectedTag = null;
+    this.oldSelectedTag = null;
+    this.resultCountBeforeNormalTags = 0;
+
+    // Lora keyword undo/redo history
+    this.textBeforeKeywordInsertion = "";
+    this.textAfterKeywordInsertion = "";
+    this.lastEditWasKeywordInsertion = false;
+    this.keywordInsertionUndone = false;
+
+    // UMI
+    this.umiPreviousTags = [];
+})();

 /// Extendability system:
 /// Provides "queues" for other files of the script (or really any js)
 /// to add functions to be called at certain points in the script.
 /// Similar to a callback system, but primitive.
+TAC.Ext = new (function () {
+    // Queues
+    this.QUEUE_AFTER_INSERT = [];
+    this.QUEUE_AFTER_SETUP = [];
+    this.QUEUE_FILE_LOAD = [];
+    this.QUEUE_AFTER_CONFIG_CHANGE = [];
+    this.QUEUE_SANITIZE = [];

-// Queues
-const QUEUE_AFTER_INSERT = [];
-const QUEUE_AFTER_SETUP = [];
-const QUEUE_FILE_LOAD = [];
-const QUEUE_AFTER_CONFIG_CHANGE = [];
-const QUEUE_SANITIZE = [];
-
-// List of parsers to try
-const PARSERS = [];
+    // List of parsers to try
+    this.PARSERS = [];
+})();
--- a/javascript/_baseParser.js
+++ b/javascript/_baseParser.js
@@ -1,21 +1,21 @@
-class FunctionNotOverriddenError extends Error {
+TAC.FunctionNotOverriddenError = class FunctionNotOverriddenError extends Error {
    constructor(message = "", ...args) {
        super(message, ...args);
        this.message = message + " is an abstract base function and must be overwritten.";
      }
 }

-class BaseTagParser {
+TAC.BaseTagParser = class BaseTagParser {
    triggerCondition = null;

    constructor (triggerCondition) {
-        if (new.target === BaseTagParser) {
+        if (new.target === TAC.BaseTagParser) {
            throw new TypeError("Cannot construct abstract BaseCompletionParser directly");
        }
        this.triggerCondition = triggerCondition;
    }

    parse() {
-        throw new FunctionNotOverriddenError("parse()");
+        throw new TAC.FunctionNotOverriddenError("parse()");
    }
 }
--- a/javascript/_caretPosition.js
+++ b/javascript/_caretPosition.js
@@ -1,145 +1,146 @@
 // From https://github.com/component/textarea-caret-position

-// We'll copy the properties below into the mirror div.
-// Note that some browsers, such as Firefox, do not concatenate properties
-// into their shorthand (e.g. padding-top, padding-bottom etc. -> padding),
-// so we have to list every single property explicitly.
-var properties = [
-  'direction',  // RTL support
-  'boxSizing',
-  'width',  // on Chrome and IE, exclude the scrollbar, so the mirror div wraps exactly as the textarea does
-  'height',
-  'overflowX',
-  'overflowY',  // copy the scrollbar for IE
+TAC.getCaretCoordinates = class CaretUtils {
+    // We'll copy the properties below into the mirror div.
+    // Note that some browsers, such as Firefox, do not concatenate properties
+    // into their shorthand (e.g. padding-top, padding-bottom etc. -> padding),
+    // so we have to list every single property explicitly.
+    static #properties = [
+        "direction", // RTL support
+        "boxSizing",
+        "width", // on Chrome and IE, exclude the scrollbar, so the mirror div wraps exactly as the textarea does
+        "height",
+        "overflowX",
+        "overflowY", // copy the scrollbar for IE

-  'borderTopWidth',
-  'borderRightWidth',
-  'borderBottomWidth',
-  'borderLeftWidth',
-  'borderStyle',
+        "borderTopWidth",
+        "borderRightWidth",
+        "borderBottomWidth",
+        "borderLeftWidth",
+        "borderStyle",

-  'paddingTop',
-  'paddingRight',
-  'paddingBottom',
-  'paddingLeft',
+        "paddingTop",
+        "paddingRight",
+        "paddingBottom",
+        "paddingLeft",

-  // https://developer.mozilla.org/en-US/docs/Web/CSS/font
-  'fontStyle',
-  'fontVariant',
-  'fontWeight',
-  'fontStretch',
-  'fontSize',
-  'fontSizeAdjust',
-  'lineHeight',
-  'fontFamily',
+        // https://developer.mozilla.org/en-US/docs/Web/CSS/font
+        "fontStyle",
+        "fontVariant",
+        "fontWeight",
+        "fontStretch",
+        "fontSize",
+        "fontSizeAdjust",
+        "lineHeight",
+        "fontFamily",

-  'textAlign',
-  'textTransform',
-  'textIndent',
-  'textDecoration',  // might not make a difference, but better be safe
+        "textAlign",
+        "textTransform",
+        "textIndent",
+        "textDecoration", // might not make a difference, but better be safe

-  'letterSpacing',
-  'wordSpacing',
+        "letterSpacing",
+        "wordSpacing",

-  'tabSize',
-  'MozTabSize'
+        "tabSize",
+        "MozTabSize",
+    ];

-];
+    static #isBrowser = typeof window !== "undefined";
+    static #isFirefox = this.#isBrowser && window.mozInnerScreenX != null;

-var isBrowser = (typeof window !== 'undefined');
-var isFirefox = (isBrowser && window.mozInnerScreenX != null);
-
-function getCaretCoordinates(element, position, options) {
-  if (!isBrowser) {
-    throw new Error('textarea-caret-position#getCaretCoordinates should only be called in a browser');
-  }
-
-  var debug = options && options.debug || false;
-  if (debug) {
-    var el = document.querySelector('#input-textarea-caret-position-mirror-div');
-    if (el) el.parentNode.removeChild(el);
-  }
-
-  // The mirror div will replicate the textarea's style
-  var div = document.createElement('div');
-  div.id = 'input-textarea-caret-position-mirror-div';
-  document.body.appendChild(div);
-
-  var style = div.style;
-  var computed = window.getComputedStyle ? window.getComputedStyle(element) : element.currentStyle;  // currentStyle for IE < 9
-  var isInput = element.nodeName === 'INPUT';
-
-  // Default textarea styles
-  style.whiteSpace = 'pre-wrap';
-  if (!isInput)
-    style.wordWrap = 'break-word';  // only for textarea-s
-
-  // Position off-screen
-  style.position = 'absolute';  // required to return coordinates properly
-  if (!debug)
-    style.visibility = 'hidden';  // not 'display: none' because we want rendering
-
-  // Transfer the element's properties to the div
-  properties.forEach(function (prop) {
-    if (isInput && prop === 'lineHeight') {
-      // Special case for <input>s because text is rendered centered and line height may be != height
-      if (computed.boxSizing === "border-box") {
-        var height = parseInt(computed.height);
-        var outerHeight =
-          parseInt(computed.paddingTop) +
-          parseInt(computed.paddingBottom) +
-          parseInt(computed.borderTopWidth) +
-          parseInt(computed.borderBottomWidth);
-        var targetHeight = outerHeight + parseInt(computed.lineHeight);
-        if (height > targetHeight) {
-          style.lineHeight = height - outerHeight + "px";
-        } else if (height === targetHeight) {
-          style.lineHeight = computed.lineHeight;
-        } else {
-          style.lineHeight = 0;
+    static getCaretCoordinates(element, position, options) {
+        if (!CaretUtils.#isBrowser) {
+            throw new Error(
+                "textarea-caret-position#getCaretCoordinates should only be called in a browser"
+            );
        }
-      } else {
-        style.lineHeight = computed.height;
-      }
-    } else {
-      style[prop] = computed[prop];
+
+        var debug = (options && options.debug) || false;
+        if (debug) {
+            var el = document.querySelector("#input-textarea-caret-position-mirror-div");
+            if (el) el.parentNode.removeChild(el);
+        }
+
+        // The mirror div will replicate the textarea's style
+        var div = document.createElement("div");
+        div.id = "input-textarea-caret-position-mirror-div";
+        document.body.appendChild(div);
+
+        var style = div.style;
+        var computed = window.getComputedStyle
+            ? window.getComputedStyle(element)
+            : element.currentStyle; // currentStyle for IE < 9
+        var isInput = element.nodeName === "INPUT";
+
+        // Default textarea styles
+        style.whiteSpace = "pre-wrap";
+        if (!isInput) style.wordWrap = "break-word"; // only for textarea-s
+
+        // Position off-screen
+        style.position = "absolute"; // required to return coordinates properly
+        if (!debug) style.visibility = "hidden"; // not 'display: none' because we want rendering
+
+        // Transfer the element's properties to the div
+        CaretUtils.#properties.forEach(function (prop) {
+            if (isInput && prop === "lineHeight") {
+                // Special case for <input>s because text is rendered centered and line height may be != height
+                if (computed.boxSizing === "border-box") {
+                    var height = parseInt(computed.height);
+                    var outerHeight =
+                        parseInt(computed.paddingTop) +
+                        parseInt(computed.paddingBottom) +
+                        parseInt(computed.borderTopWidth) +
+                        parseInt(computed.borderBottomWidth);
+                    var targetHeight = outerHeight + parseInt(computed.lineHeight);
+                    if (height > targetHeight) {
+                        style.lineHeight = height - outerHeight + "px";
+                    } else if (height === targetHeight) {
+                        style.lineHeight = computed.lineHeight;
+                    } else {
+                        style.lineHeight = 0;
+                    }
+                } else {
+                    style.lineHeight = computed.height;
+                }
+            } else {
+                style[prop] = computed[prop];
+            }
+        });
+
+        if (CaretUtils.#isFirefox) {
+            // Firefox lies about the overflow property for textareas: https://bugzilla.mozilla.org/show_bug.cgi?id=984275
+            if (element.scrollHeight > parseInt(computed.height)) style.overflowY = "scroll";
+        } else {
+            style.overflow = "hidden"; // for Chrome to not render a scrollbar; IE keeps overflowY = 'scroll'
+        }
+
+        div.textContent = element.value.substring(0, position);
+        // The second special handling for input type="text" vs textarea:
+        // spaces need to be replaced with non-breaking spaces - http://stackoverflow.com/a/13402035/1269037
+        if (isInput) div.textContent = div.textContent.replace(/\s/g, "\u00a0");
+
+        var span = document.createElement("span");
+        // Wrapping must be replicated *exactly*, including when a long word gets
+        // onto the next line, with whitespace at the end of the line before (#7).
+        // The  *only* reliable way to do that is to copy the *entire* rest of the
+        // textarea's content into the <span> created at the caret position.
+        // For inputs, just '.' would be enough, but no need to bother.
+        span.textContent = element.value.substring(position) || "."; // || because a completely empty faux span doesn't render at all
+        div.appendChild(span);
+
+        var coordinates = {
+            top: span.offsetTop + parseInt(computed["borderTopWidth"]),
+            left: span.offsetLeft + parseInt(computed["borderLeftWidth"]),
+            height: parseInt(computed["lineHeight"]),
+        };
+
+        if (debug) {
+            span.style.backgroundColor = "#aaa";
+        } else {
+            document.body.removeChild(div);
+        }
+
+        return coordinates;
    }
-  });
-
-  if (isFirefox) {
-    // Firefox lies about the overflow property for textareas: https://bugzilla.mozilla.org/show_bug.cgi?id=984275
-    if (element.scrollHeight > parseInt(computed.height))
-      style.overflowY = 'scroll';
-  } else {
-    style.overflow = 'hidden';  // for Chrome to not render a scrollbar; IE keeps overflowY = 'scroll'
-  }
-
-  div.textContent = element.value.substring(0, position);
-  // The second special handling for input type="text" vs textarea:
-  // spaces need to be replaced with non-breaking spaces - http://stackoverflow.com/a/13402035/1269037
-  if (isInput)
-    div.textContent = div.textContent.replace(/\s/g, '\u00a0');
-
-  var span = document.createElement('span');
-  // Wrapping must be replicated *exactly*, including when a long word gets
-  // onto the next line, with whitespace at the end of the line before (#7).
-  // The  *only* reliable way to do that is to copy the *entire* rest of the
-  // textarea's content into the <span> created at the caret position.
-  // For inputs, just '.' would be enough, but no need to bother.
-  span.textContent = element.value.substring(position) || '.';  // || because a completely empty faux span doesn't render at all
-  div.appendChild(span);
-
-  var coordinates = {
-    top: span.offsetTop + parseInt(computed['borderTopWidth']),
-    left: span.offsetLeft + parseInt(computed['borderLeftWidth']),
-    height: parseInt(computed['lineHeight'])
-  };
-
-  if (debug) {
-    span.style.backgroundColor = '#aaa';
-  } else {
-    document.body.removeChild(div);
-  }
-
-  return coordinates;
-}
+}.getCaretCoordinates;
--- a/javascript/_result.js
+++ b/javascript/_result.js
@@ -1,30 +1,35 @@
 // Result data type for cleaner use of optional completion result properties

 // Type enum
-const ResultType = Object.freeze({
+TAC.ResultType = Object.freeze({
    "tag": 1,
    "extra": 2,
    "embedding": 3,
    "wildcardTag": 4,
    "wildcardFile": 5,
    "yamlWildcard": 6,
-    "hypernetwork": 7,
-    "lora": 8,
-    "lyco": 9,
-    "chant": 10
+    "umiWildcard": 7,
+    "hypernetwork": 8,
+    "lora": 9,
+    "lyco": 10,
+    "chant": 11,
+    "styleName": 12
 });

 // Class to hold result data and annotations to make it clearer to use
-class AutocompleteResult {
+TAC.AutocompleteResult = class AutocompleteResult {
    // Main properties
    text = "";
-    type = ResultType.tag;
+    type = TAC.ResultType.tag;

    // Additional info, only used in some cases
    category = null;
-    count = null;
+    count = Number.MAX_SAFE_INTEGER;
+    usageBias = null;
    aliases = null;
    meta = null;
+    hash = null;
+    sortKey = null;

    // Constructor
    constructor(text, type) {
--- a/javascript/_textAreas.js
+++ b/javascript/_textAreas.js
@@ -1,168 +1,218 @@
 // Utility functions to select text areas the script should work on,
 // including third party options.
-// Supported third party options so far:
-// - Dataset Tag Editor

-// Core text area selectors
-const core = [
-    "#txt2img_prompt > label > textarea",
-    "#img2img_prompt > label > textarea",
-    "#txt2img_neg_prompt > label > textarea",
-    "#img2img_neg_prompt > label > textarea",
-    ".prompt > label > textarea"
-];
+TAC.TextAreas = new (function () {
+    // Core text area selectors
+    const core = [
+        "#txt2img_prompt > label > textarea",
+        "#img2img_prompt > label > textarea",
+        "#txt2img_neg_prompt > label > textarea",
+        "#img2img_neg_prompt > label > textarea",
+        ".prompt > label > textarea",
+        "#txt2img_edit_style_prompt > label > textarea",
+        "#txt2img_edit_style_neg_prompt > label > textarea",
+        "#img2img_edit_style_prompt > label > textarea",
+        "#img2img_edit_style_neg_prompt > label > textarea",
+    ];

-// Third party text area selectors
-const thirdParty = {
-    "dataset-tag-editor": {
-        "base": "#tab_dataset_tag_editor_interface",
-        "hasIds": false,
-        "selectors": [
-            "Caption of Selected Image",
-            "Interrogate Result",
-            "Edit Caption",
-            "Edit Tags"
-        ]
-    },
-    "image browser": {
-        "base": "#tab_image_browser",
-        "hasIds": false,
-        "selectors": [
-            "Filename keyword search",
-            "EXIF keyword search"
-        ]
-    },
-    "tab_tagger": {
-        "base": "#tab_tagger",
-        "hasIds": false,
-        "selectors": [
-            "Additional tags (split by comma)",
-            "Exclude tags (split by comma)"
-        ]
-    },
-    "tiled-diffusion-t2i": {
-        "base": "#txt2img_script_container",
-        "hasIds": true,
-        "onDemand": true,
-        "selectors": [
-            "[id^=MD-t2i][id$=prompt] textarea",
-            "[id^=MD-t2i][id$=prompt] input[type='text']"
-        ]
-    },
-    "tiled-diffusion-i2i": {
-        "base": "#img2img_script_container",
-        "hasIds": true,
-        "onDemand": true,
-        "selectors": [
-            "[id^=MD-i2i][id$=prompt] textarea",
-            "[id^=MD-i2i][id$=prompt] input[type='text']"
-        ]
+    // Third party text area selectors
+    const thirdParty = {
+        "dataset-tag-editor": {
+            base: "#tab_dataset_tag_editor_interface",
+            hasIds: false,
+            selectors: [
+                "Caption of Selected Image",
+                "Interrogate Result",
+                "Edit Caption",
+                "Edit Tags",
+            ],
+        },
+        "image browser": {
+            base: "#tab_image_browser",
+            hasIds: false,
+            selectors: ["Filename keyword search", "EXIF keyword search"],
+        },
+        tab_tagger: {
+            base: "#tab_tagger",
+            hasIds: false,
+            selectors: ["Additional tags (split by comma)", "Exclude tags (split by comma)"],
+        },
+        "tiled-diffusion-t2i": {
+            base: "#txt2img_script_container",
+            hasIds: true,
+            onDemand: true,
+            selectors: [
+                "[id^=MD-t2i][id$=prompt] textarea",
+                "[id^=MD-t2i][id$=prompt] input[type='text']",
+            ],
+        },
+        "tiled-diffusion-i2i": {
+            base: "#img2img_script_container",
+            hasIds: true,
+            onDemand: true,
+            selectors: [
+                "[id^=MD-i2i][id$=prompt] textarea",
+                "[id^=MD-i2i][id$=prompt] input[type='text']",
+            ],
+        },
+        "adetailer-t2i": {
+            base: "#txt2img_script_container",
+            hasIds: true,
+            onDemand: true,
+            selectors: [
+                "[id^=script_txt2img_adetailer_ad_prompt] textarea",
+                "[id^=script_txt2img_adetailer_ad_negative_prompt] textarea",
+            ],
+        },
+        "adetailer-i2i": {
+            base: "#img2img_script_container",
+            hasIds: true,
+            onDemand: true,
+            selectors: [
+                "[id^=script_img2img_adetailer_ad_prompt] textarea",
+                "[id^=script_img2img_adetailer_ad_negative_prompt] textarea",
+            ],
+        },
+        "deepdanbooru-object-recognition": {
+            base: "#tab_deepdanboru_object_recg_tab",
+            hasIds: false,
+            selectors: ["Found tags"],
+        },
+        TIPO: {
+            base: "#tab_txt2img",
+            hasIds: false,
+            selectors: ["Tag Prompt"],
+        },
+    };
+
+    this.getTextAreas = function () {
+        // First get all core text areas
+        let textAreas = [...gradioApp().querySelectorAll(core.join(", "))];
+
+        for (const [key, entry] of Object.entries(thirdParty)) {
+            if (entry.hasIds) {
+                // If the entry has proper ids, we can just select them
+                textAreas = textAreas.concat([
+                    ...gradioApp().querySelectorAll(entry.selectors.join(", ")),
+                ]);
+            } else {
+                // Otherwise, we have to find the text areas by their adjacent labels
+                let base = gradioApp().querySelector(entry.base);
+
+                // Safety check
+                if (!base) continue;
+
+                let allTextAreas = [...base.querySelectorAll("textarea, input[type='text']")];
+
+                // Filter the text areas where the adjacent label matches one of the selectors
+                let matchingTextAreas = allTextAreas.filter((ta) =>
+                    [...ta.parentElement.childNodes].some((x) =>
+                        entry.selectors.includes(x.innerText)
+                    )
+                );
+                textAreas = textAreas.concat(matchingTextAreas);
+            }
+        }
+
+        return textAreas;
    }
-}

-function getTextAreas() {
-    // First get all core text areas
-    let textAreas = [...gradioApp().querySelectorAll(core.join(", "))];
+    this.addOnDemandObservers = function (setupFunction) {
+        for (const [key, entry] of Object.entries(thirdParty)) {
+            if (!entry.onDemand) continue;

-    for (const [key, entry] of Object.entries(thirdParty)) {
-        if (entry.hasIds) { // If the entry has proper ids, we can just select them
-            textAreas = textAreas.concat([...gradioApp().querySelectorAll(entry.selectors.join(", "))]);
-        } else { // Otherwise, we have to find the text areas by their adjacent labels
            let base = gradioApp().querySelector(entry.base);
-
-            // Safety check
            if (!base) continue;

-            let allTextAreas = [...base.querySelectorAll("textarea, input[type='text']")];
+            let accordions = [...base?.querySelectorAll(".gradio-accordion")];
+            if (!accordions) continue;

-            // Filter the text areas where the adjacent label matches one of the selectors
-            let matchingTextAreas = allTextAreas.filter(ta => [...ta.parentElement.childNodes].some(x => entry.selectors.includes(x.innerText)));
-            textAreas = textAreas.concat(matchingTextAreas);
-        }
-    };
-
-    return textAreas;
-}
-
-function addOnDemandObservers(setupFunction) {
-    for (const [key, entry] of Object.entries(thirdParty)) {
-        if (!entry.onDemand) continue;
-
-        let base = gradioApp().querySelector(entry.base);
-        if (!base) continue;
-        
-        let accordions = [...base?.querySelectorAll(".gradio-accordion")];
-        if (!accordions) continue;
-
-        accordions.forEach(acc => {
-            let accObserver = new MutationObserver((mutationList, observer) => {
-                for (const mutation of mutationList) {
-                    if (mutation.type === "childList") {
-                        let newChildren = mutation.addedNodes;
-                        if (!newChildren) {
-                            accObserver.disconnect();
-                            continue;
-                        }
-
-                        newChildren.forEach(child => {
-                            if (child.classList.contains("gradio-accordion") || child.querySelector(".gradio-accordion")) {
-                                let newAccordions = [...child.querySelectorAll(".gradio-accordion")];
-                                newAccordions.forEach(nAcc => accObserver.observe(nAcc, { childList: true }));
+            accordions.forEach((acc) => {
+                let accObserver = new MutationObserver((mutationList, observer) => {
+                    for (const mutation of mutationList) {
+                        if (mutation.type === "childList") {
+                            let newChildren = mutation.addedNodes;
+                            if (!newChildren) {
+                                accObserver.disconnect();
+                                continue;
                            }
-                        });

-                        if (entry.hasIds) { // If the entry has proper ids, we can just select them
-                            [...gradioApp().querySelectorAll(entry.selectors.join(", "))].forEach(x => setupFunction(x));
-                        } else { // Otherwise, we have to find the text areas by their adjacent labels
-                            let base = gradioApp().querySelector(entry.base);
-                
-                            // Safety check
-                            if (!base) continue;
-                
-                            let allTextAreas = [...base.querySelectorAll("textarea, input[type='text']")];
-                
-                            // Filter the text areas where the adjacent label matches one of the selectors
-                            let matchingTextAreas = allTextAreas.filter(ta => [...ta.parentElement.childNodes].some(x => entry.selectors.includes(x.innerText)));
-                            matchingTextAreas.forEach(x => setupFunction(x));
+                            newChildren.forEach((child) => {
+                                if (
+                                    child.classList.contains("gradio-accordion") ||
+                                    child.querySelector(".gradio-accordion")
+                                ) {
+                                    let newAccordions = [
+                                        ...child.querySelectorAll(".gradio-accordion"),
+                                    ];
+                                    newAccordions.forEach((nAcc) =>
+                                        accObserver.observe(nAcc, { childList: true })
+                                    );
+                                }
+                            });
+
+                            if (entry.hasIds) {
+                                // If the entry has proper ids, we can just select them
+                                [
+                                    ...gradioApp().querySelectorAll(entry.selectors.join(", ")),
+                                ].forEach((x) => setupFunction(x));
+                            } else {
+                                // Otherwise, we have to find the text areas by their adjacent labels
+                                let base = gradioApp().querySelector(entry.base);
+
+                                // Safety check
+                                if (!base) continue;
+
+                                let allTextAreas = [
+                                    ...base.querySelectorAll("textarea, input[type='text']"),
+                                ];
+
+                                // Filter the text areas where the adjacent label matches one of the selectors
+                                let matchingTextAreas = allTextAreas.filter((ta) =>
+                                    [...ta.parentElement.childNodes].some((x) =>
+                                        entry.selectors.includes(x.innerText)
+                                    )
+                                );
+                                matchingTextAreas.forEach((x) => setupFunction(x));
+                            }
                        }
                    }
-                }
+                });
+                accObserver.observe(acc, { childList: true });
            });
-            accObserver.observe(acc, { childList: true });
-        });
-    };
-}
-
-const thirdPartyIdSet = new Set();
-// Get the identifier for the text area to differentiate between positive and negative
-function getTextAreaIdentifier(textArea) {
-    let txt2img_p = gradioApp().querySelector('#txt2img_prompt > label > textarea');
-    let txt2img_n = gradioApp().querySelector('#txt2img_neg_prompt > label > textarea');
-    let img2img_p = gradioApp().querySelector('#img2img_prompt > label > textarea');
-    let img2img_n = gradioApp().querySelector('#img2img_neg_prompt > label > textarea');
-
-    let modifier = "";
-    switch (textArea) {
-        case txt2img_p:
-            modifier = ".txt2img.p";
-            break;
-        case txt2img_n:
-            modifier = ".txt2img.n";
-            break;
-        case img2img_p:
-            modifier = ".img2img.p";
-            break;
-        case img2img_n:
-            modifier = ".img2img.n";
-            break;
-        default:
-            // If the text area is not a core text area, it must be a third party text area
-            // Add it to the set of third party text areas and get its index as a unique identifier
-            if (!thirdPartyIdSet.has(textArea))
-                thirdPartyIdSet.add(textArea);
-
-            modifier = `.thirdParty.ta${[...thirdPartyIdSet].indexOf(textArea)}`;
-            break;
+        }
    }
-    return modifier;
-}
+
+    const thirdPartyIdSet = new Set();
+    // Get the identifier for the text area to differentiate between positive and negative
+    this.getTextAreaIdentifier = function (textArea) {
+        let txt2img_p = gradioApp().querySelector("#txt2img_prompt > label > textarea");
+        let txt2img_n = gradioApp().querySelector("#txt2img_neg_prompt > label > textarea");
+        let img2img_p = gradioApp().querySelector("#img2img_prompt > label > textarea");
+        let img2img_n = gradioApp().querySelector("#img2img_neg_prompt > label > textarea");
+
+        let modifier = "";
+        switch (textArea) {
+            case txt2img_p:
+                modifier = ".txt2img.p";
+                break;
+            case txt2img_n:
+                modifier = ".txt2img.n";
+                break;
+            case img2img_p:
+                modifier = ".img2img.p";
+                break;
+            case img2img_n:
+                modifier = ".img2img.n";
+                break;
+            default:
+                // If the text area is not a core text area, it must be a third party text area
+                // Add it to the set of third party text areas and get its index as a unique identifier
+                if (!thirdPartyIdSet.has(textArea)) thirdPartyIdSet.add(textArea);
+
+                modifier = `.thirdParty.ta${[...thirdPartyIdSet].indexOf(textArea)}`;
+                break;
+        }
+        return modifier;
+    }
+})();
--- a/javascript/_utils.js
+++ b/javascript/_utils.js
@@ -1,173 +1,624 @@
 // Utility functions for tag autocomplete
+TAC.Utils = class TacUtils {
+    /**
+     * Parses a CSV file into a 2D array. Doesn't use regex, so it is very lightweight.
+     * We are ignoring newlines in quote fields since we expect one-line entries and parsing would break for unclosed quotes otherwise
+     * @param {String} str - The CSV string to parse (likely from a file with multiple lines)
+     * @returns {string[][]} A 2D array of CSV entries (rows and columns of that row)
+     */
+    static parseCSV(str) {
+        const arr = [];
+        let quote = false; // 'true' means we're inside a quoted field

-// Parse the CSV file into a 2D array. Doesn't use regex, so it is very lightweight.
-function parseCSV(str) {
-    var arr = [];
-    var quote = false;  // 'true' means we're inside a quoted field
+        // Iterate over each character, keep track of current row and column (of the returned array)
+        for (let row = 0, col = 0, c = 0; c < str.length; c++) {
+            let cc = str[c],
+                nc = str[c + 1]; // Current character, next character
+            arr[row] = arr[row] || []; // Create a new row if necessary
+            arr[row][col] = arr[row][col] || ""; // Create a new column (start with empty string) if necessary

-    // Iterate over each character, keep track of current row and column (of the returned array)
-    for (var row = 0, col = 0, c = 0; c < str.length; c++) {
-        var cc = str[c], nc = str[c + 1];        // Current character, next character
-        arr[row] = arr[row] || [];             // Create a new row if necessary
-        arr[row][col] = arr[row][col] || '';   // Create a new column (start with empty string) if necessary
+            // If the current character is a quotation mark, and we're inside a
+            // quoted field, and the next character is also a quotation mark,
+            // add a quotation mark to the current column and skip the next character
+            if (cc == '"' && quote && nc == '"') {
+                arr[row][col] += cc;
+                ++c;
+                continue;
+            }

-        // If the current character is a quotation mark, and we're inside a
-        // quoted field, and the next character is also a quotation mark,
-        // add a quotation mark to the current column and skip the next character
-        if (cc == '"' && quote && nc == '"') { arr[row][col] += cc; ++c; continue; }
+            // If it's just one quotation mark, begin/end quoted field
+            if (cc == '"') {
+                quote = !quote;
+                continue;
+            }

-        // If it's just one quotation mark, begin/end quoted field
-        if (cc == '"') { quote = !quote; continue; }
+            // If it's a comma and we're not in a quoted field, move on to the next column
+            if (cc == "," && !quote) {
+                ++col;
+                continue;
+            }

-        // If it's a comma and we're not in a quoted field, move on to the next column
-        if (cc == ',' && !quote) { ++col; continue; }
+            // If it's a newline (CRLF), skip the next character and move on to the next row and move to column 0 of that new row
+            if (cc == "\r" && nc == "\n") {
+                ++row;
+                col = 0;
+                ++c;
+                quote = false;
+                continue;
+            }

-        // If it's a newline (CRLF) and we're not in a quoted field, skip the next character
-        // and move on to the next row and move to column 0 of that new row
-        if (cc == '\r' && nc == '\n' && !quote) { ++row; col = 0; ++c; continue; }
+            // If it's a newline (LF or CR) move on to the next row and move to column 0 of that new row
+            if (cc == "\n") {
+                ++row;
+                col = 0;
+                quote = false;
+                continue;
+            }
+            if (cc == "\r") {
+                ++row;
+                col = 0;
+                quote = false;
+                continue;
+            }

-        // If it's a newline (LF or CR) and we're not in a quoted field,
-        // move on to the next row and move to column 0 of that new row
-        if (cc == '\n' && !quote) { ++row; col = 0; continue; }
-        if (cc == '\r' && !quote) { ++row; col = 0; continue; }
-
-        // Otherwise, append the current character to the current column
-        arr[row][col] += cc;
-    }
-    return arr;
-}
-
-// Load file
-async function readFile(filePath, json = false, cache = false) {
-    if (!cache)
-        filePath += `?${new Date().getTime()}`;
-        
-    let response = await fetch(`file=${filePath}`);
-
-    if (response.status != 200) {
-        console.error(`Error loading file "${filePath}": ` + response.status, response.statusText);
-        return null;
+            // Otherwise, append the current character to the current column
+            arr[row][col] += cc;
+        }
+        return arr;
    }

-    if (json)
-        return await response.json();
-    else
-        return await response.text();
-}
+    /** Wrapper function to read a file from a path, using Gradio's "file="" accessor API
+     * @param {String} filePath - The path to the file
+     * @param {Boolean} json - Whether to parse the file as JSON
+     * @param {Boolean} cache - Whether to cache the response
+     * @returns {Promise<String | any>} The file content as a string or JSON object (if json is true)
+     */
+    static async readFile(filePath, json = false, cache = false) {
+        if (!cache) filePath += `?${new Date().getTime()}`;

-// Load CSV
-async function loadCSV(path) {
-    let text = await readFile(path);
-    return parseCSV(text);
-}
+        let response = await fetch(`file=${filePath}`);

-// Debounce function to prevent spamming the autocomplete function
-var dbTimeOut;
-const debounce = (func, wait = 300) => {
-    return function (...args) {
-        if (dbTimeOut) {
-            clearTimeout(dbTimeOut);
+        if (response.status != 200) {
+            console.error(
+                `Error loading file "${filePath}": ` + response.status,
+                response.statusText
+            );
+            return null;
        }

-        dbTimeOut = setTimeout(() => {
-            func.apply(this, args);
-        }, wait);
-    }
-}
-
-// Difference function to fix duplicates not being seen as changes in normal filter
-function difference(a, b) {
-    if (a.length == 0) {
-        return b;
-    }
-    if (b.length == 0) {
-        return a;
+        if (json) return await response.json();
+        else return await response.text();
    }

-    return [...b.reduce((acc, v) => acc.set(v, (acc.get(v) || 0) - 1),
-        a.reduce((acc, v) => acc.set(v, (acc.get(v) || 0) + 1), new Map())
-    )].reduce((acc, [v, count]) => acc.concat(Array(Math.abs(count)).fill(v)), []);
-}
-
-// Sliding window function to get possible combination groups of an array
-function toNgrams(inputArray, size) {
-    return Array.from(
-        { length: inputArray.length - (size - 1) }, //get the appropriate length
-        (_, index) => inputArray.slice(index, index + size) //create the windows
-    );
-}
-
-function escapeRegExp(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
-}
-function escapeHTML(unsafeText) {
-    let div = document.createElement('div');
-    div.textContent = unsafeText;
-    return div.innerHTML;
-}
-
-// For black/whitelisting
-function updateModelName() {
-    let sdm = gradioApp().querySelector("#setting_sd_model_checkpoint");
-    let modelDropdown =  sdm?.querySelector("input") || sdm?.querySelector("select");
-    if (modelDropdown) {
-        currentModelName = modelDropdown.value;
-    } else {
-        // Fallback for intermediate versions
-        modelDropdown = sdm?.querySelector("span.single-select");
-        currentModelName = modelDropdown?.textContent || "";
+    /** Wrapper function to read a file from the path and parse it as CSV
+     * @param {String} path - The path to the CSV file
+     * @returns {Promise<String[][]>} A 2D array of CSV entries
+     */
+    static async loadCSV(path) {
+        let text = await this.readFile(path);
+        return this.parseCSV(text);
    }
-}

-// From https://stackoverflow.com/a/61975440, how to detect JS value changes
-function observeElement(element, property, callback, delay = 0) {
-    let elementPrototype = Object.getPrototypeOf(element);
-    if (elementPrototype.hasOwnProperty(property)) {
-        let descriptor = Object.getOwnPropertyDescriptor(elementPrototype, property);
-        Object.defineProperty(element, property, {
-            get: function() {
-                return descriptor.get.apply(this, arguments);
-            },
-            set: function () {
-                let oldValue = this[property];
-                descriptor.set.apply(this, arguments);
-                let newValue = this[property];
-                if (typeof callback == "function") {
-                    setTimeout(callback.bind(this, oldValue, newValue), delay);
-                }
-                return newValue;
+    /**
+     * Calls the TAC API for a GET request
+     * @param {String} url - The URL to fetch from
+     * @param {Boolean} json - Whether to parse the response as JSON or plain text
+     * @param {Boolean} cache - Whether to cache the response
+     * @returns {Promise<any | String>} JSON or text response from the API, depending on the "json" parameter
+     */
+    static async fetchAPI(url, json = true, cache = false) {
+        if (!cache) {
+            const appendChar = url.includes("?") ? "&" : "?";
+            url += `${appendChar}${new Date().getTime()}`;
+        }
+
+        let response = await fetch(url);
+
+        if (response.status != 200) {
+            console.error(
+                `Error fetching API endpoint "${url}": ` + response.status,
+                response.statusText
+            );
+            return null;
+        }
+
+        if (json) return await response.json();
+        else return await response.text();
+    }
+
+    /**
+     * Posts to the TAC API
+     * @param {String} url - The URL to post to
+     * @param {String} body - (optional) The body of the POST request as a JSON string
+     * @returns JSON response from the API
+     */
+    static async postAPI(url, body = null) {
+        let response = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: body,
+        });
+
+        if (response.status != 200) {
+            console.error(
+                `Error posting to API endpoint "${url}": ` + response.status,
+                response.statusText
+            );
+            return null;
+        }
+
+        return await response.json();
+    }
+
+    /**
+     * Puts to the TAC API
+     * @param {String} url - The URL to post to
+     * @param {String} body - (optional) The body of the PUT request as a JSON string
+     * @returns JSON response from the API
+     */
+    static async putAPI(url, body = null) {
+        let response = await fetch(url, { method: "PUT", body: body });
+
+        if (response.status != 200) {
+            console.error(
+                `Error putting to API endpoint "${url}": ` + response.status,
+                response.statusText
+            );
+            return null;
+        }
+
+        return await response.json();
+    }
+
+    /**
+     * Get a preview image URL for a given extra network file.
+     * Uses the official webui endpoint if available, otherwise creates a blob URL.
+     * @param {String} filename - The filename of the extra network file
+     * @param {String} type - One of "embed", "hyper", "lora", or "lyco", to determine the lookup location
+     * @returns {Promise<String>} URL to a preview image for the extra network file, if available
+     */
+    static async getExtraNetworkPreviewURL(filename, type) {
+        const previewJSON = await this.fetchAPI(
+            `tacapi/v1/thumb-preview/${filename}?type=${type}`,
+            true,
+            true
+        );
+        if (previewJSON?.url) {
+            const properURL = `sd_extra_networks/thumb?filename=${previewJSON.url}`;
+            if ((await fetch(properURL)).status == 200) {
+                return properURL;
+            } else {
+                // create blob url
+                const blob = await (
+                    await fetch(`tacapi/v1/thumb-preview-blob/${filename}?type=${type}`)
+                ).blob();
+                return URL.createObjectURL(blob);
            }
+        } else {
+            return null;
+        }
+    }
+
+    static #lastStyleRefresh = 0;
+    /**
+     * Refreshes the styles.txt file if it has changed since the last check.
+     * Checks at most once per second to prevent spamming the API.
+     */
+    static async refreshStyleNamesIfChanged() {
+        // Only refresh once per second
+        let currentTimestamp = new Date().getTime();
+        if (currentTimestamp - this.#lastStyleRefresh < 1000) return;
+        this.#lastStyleRefresh = currentTimestamp;
+
+        const response = await fetch(`tacapi/v1/refresh-styles-if-changed?${new Date().getTime()}`);
+        if (response.status === 304) {
+            // Not modified
+        } else if (response.status === 200) {
+            // Reload
+            TAC.Ext.QUEUE_FILE_LOAD.forEach(async (fn) => {
+                if (fn.toString().includes("styleNames")) await fn.call(null, true);
+            });
+        } else {
+            // Error
+            console.error(`Error refreshing styles.txt: ` + response.status, response.statusText);
+        }
+    }
+
+    static #dbTimeOut;
+    /**
+     * Generic debounce function to prevent spamming the autocompletion during fast typing
+     * @param {Function} func - The function to debounce
+     * @param {Number} wait - The debounce time in milliseconds
+     * @returns {Function} The debounced function
+     */
+    static debounce = (func, wait = 300) => {
+        return function (...args) {
+            // Caution: Since we are in an anonymous function, 'this' would not refer to the class
+            if (TacUtils.#dbTimeOut) {
+                clearTimeout(TacUtils.#dbTimeOut);
+            }
+
+            TacUtils.#dbTimeOut = setTimeout(() => {
+                func.apply(this, args);
+            }, wait);
+        };
+    };
+
+    /**
+     * Calculates the difference between two arrays (order-sensitive).
+     * Fixes duplicates not being seen as changes in a normal filter function.
+     * @param {Array} a
+     * @param {Array} b
+     * @returns {Array} The difference between the two arrays
+     */
+    static difference(a, b) {
+        if (a.length == 0) {
+            return b;
+        }
+        if (b.length == 0) {
+            return a;
+        }
+
+        return [
+            ...b.reduce(
+                (acc, v) => acc.set(v, (acc.get(v) || 0) - 1),
+                a.reduce((acc, v) => acc.set(v, (acc.get(v) || 0) + 1), new Map())
+            ),
+        ].reduce((acc, [v, count]) => acc.concat(Array(Math.abs(count)).fill(v)), []);
+    }
+
+    /**
+     * Object flatten function adapted from https://stackoverflow.com/a/61602592
+     * @param {*} obj - The object to flatten
+     * @param {Array} roots - Keeps previous parent properties as they will be added as a prefix for each prop.
+     * @param {String} sep - Just a preference if you want to seperate nested paths other than dot.
+     * @returns The flattened object
+     */
+    static flatten(obj, roots = [], sep = ".") {
+        return Object.keys(obj).reduce(
+            (memo, prop) =>
+                Object.assign(
+                    // create a new object
+                    {},
+                    // include previously returned object
+                    memo,
+                    Object.prototype.toString.call(obj[prop]) === "[object Object]"
+                        ? // keep working if value is an object
+                          this.flatten(obj[prop], roots.concat([prop]), sep)
+                        : // include current prop and value and prefix prop with the roots
+                          { [roots.concat([prop]).join(sep)]: obj[prop] }
+                ),
+            {}
+        );
+    }
+
+    /**
+     * Calculate biased tag score based on post count and frequent usage
+     * @param {TAC.AutocompleteResult} result - The unbiased result
+     * @param {Number} count - The post count (or similar base metric)
+     * @param {Number} uses - The usage count
+     * @returns {Number} The biased score for sorting
+     */
+    static calculateUsageBias(result, count, uses) {
+        // Check setting conditions
+        if (uses < TAC.CFG.frequencyMinCount) {
+            uses = 0;
+        } else if (uses != 0) {
+            result.usageBias = true;
+        }
+
+        switch (TAC.CFG.frequencyFunction) {
+            case "Logarithmic (weak)":
+                return Math.log(1 + count) + Math.log(1 + uses);
+            case "Logarithmic (strong)":
+                return Math.log(1 + count) + 2 * Math.log(1 + uses);
+            case "Usage first":
+                return uses;
+            default:
+                return count;
+        }
+    }
+    /**
+     * Utility function to map the use count array from the database to a more readable format,
+     * since FastAPI omits the field names in the response.
+     * @param {Array} useCounts
+     * @param {Boolean} posAndNeg - Whether to include negative counts
+     */
+    static mapUseCountArray(useCounts, posAndNeg = false) {
+        return useCounts.map((useCount) => {
+            if (posAndNeg) {
+                return {
+                    name: useCount[0],
+                    type: useCount[1],
+                    count: useCount[2],
+                    negCount: useCount[3],
+                    lastUseDate: useCount[4],
+                };
+            }
+            return {
+                name: useCount[0],
+                type: useCount[1],
+                count: useCount[2],
+                lastUseDate: useCount[3],
+            };
        });
    }
-}
-
-// Queue calling function to process global queues
-async function processQueue(queue, context, ...args) {
-    for (let i = 0; i < queue.length; i++) {
-        await queue[i].call(context, ...args);
-    }
-}
-// The same but with return values
-async function processQueueReturn(queue, context, ...args)
-{
-    let qeueueReturns = [];
-    for (let i = 0; i < queue.length; i++) {
-        let returnValue = await queue[i].call(context, ...args);
-        if (returnValue)
-            qeueueReturns.push(returnValue);
-    }
-    return qeueueReturns;
-}
-// Specific to tag completion parsers
-async function processParsers(textArea, prompt) {
-    // Get all parsers that have a successful trigger condition
-    let matchingParsers = PARSERS.filter(parser => parser.triggerCondition());
-    // Guard condition
-    if (matchingParsers.length === 0) {
-        return null;
+    /**
+     * Calls API endpoint to increase the count of a tag in the database.
+     * Not awaited as it is non-critical and can be executed as fire-and-forget.
+     * @param {String} tagName - The name of the tag
+     * @param {TAC.ResultType} type - The type of the tag as mapped in {@link TAC.ResultType}
+     * @param {Boolean} negative - Whether the tag was typed in a negative prompt field
+     */
+    static increaseUseCount(tagName, type, negative = false) {
+        this.postAPI(
+            `tacapi/v1/increase-use-count?tagname=${tagName}&ttype=${type}&neg=${negative}`
+        );
    }

-    let parseFunctions = matchingParsers.map(parser => parser.parse);
-    // Process them and return the results
-    return await processQueueReturn(parseFunctions, null, textArea, prompt);
-}
+    /**
+     * Get the use count of a tag from the database
+     * @param {String} tagName - The name of the tag
+     * @param {TAC.ResultType} type - The type of the tag as mapped in {@link TAC.ResultType}
+     * @param {Boolean} negative - Whether we are currently in a negative prompt field
+     * @returns {Promise<Number>} The use count of the tag
+     */
+    static async getUseCount(tagName, type, negative = false) {
+        const response = await this.fetchAPI(
+            `tacapi/v1/get-use-count?tagname=${tagName}&ttype=${type}&neg=${negative}`,
+            true,
+            false
+        );
+        // Guard for no db
+        if (response == null) return null;
+        // Result
+        return response["result"];
+    }
+    /**
+     * Retrieves the use counts of multiple tags at once from the database for improved performance
+     * during typing.
+     * @param {String[]} tagNames - An array of tag names
+     * @param {TAC.ResultType[]} types - An array of tag types as mapped in {@link TAC.ResultType}
+     * @param {Boolean} negative - Whether we are currently in a negative prompt field
+     * @returns {Promise<Array>} The use count array mapped to named fields by {@link mapUseCountArray}
+     */
+    static async getUseCounts(tagNames, types, negative = false) {
+        // While semantically weird, we have to use POST here for the body, as urls are limited in length
+        const body = JSON.stringify({ tagNames: tagNames, tagTypes: types, neg: negative });
+        const response = await this.postAPI(`tacapi/v1/get-use-count-list`, body);
+        // Guard for no db
+        if (response == null) return null;
+        // Results
+        return this.mapUseCountArray(response["result"]);
+    }
+    /**
+     * Gets all use counts existing in the database.
+     * @returns {Array} The use count array mapped to named fields by {@link mapUseCountArray}
+     */
+    static async getAllUseCounts() {
+        const response = await this.fetchAPI(`tacapi/v1/get-all-use-counts`);
+        // Guard for no db
+        if (response == null) return null;
+        // Results
+        return this.mapUseCountArray(response["result"], true);
+    }
+    /**
+     * Resets the use count of the given tag back to zero.
+     * @param {String} tagName - The name of the tag
+     * @param {TAC.ResultType} type - The type of the tag as mapped in {@link TAC.ResultType}
+     * @param {Boolean} resetPosCount - Whether to reset the positive count
+     * @param {Boolean} resetNegCount - Whether to reset the negative count
+     */
+    static async resetUseCount(tagName, type, resetPosCount, resetNegCount) {
+        await this.putAPI(
+            `tacapi/v1/reset-use-count?tagname=${tagName}&ttype=${type}&pos=${resetPosCount}&neg=${resetNegCount}`
+        );
+    }
+
+    /**
+     * Creates a table to display an overview of tag usage statistics.
+     * Currently unused.
+     * @param {Array} tagCounts - The use count array to use, mapped to named fields by {@link mapUseCountArray}
+     * @returns
+     */
+    static createTagUsageTable(tagCounts) {
+        // Create table
+        let tagTable = document.createElement("table");
+        tagTable.innerHTML = `<thead>
+            <tr>
+                <td>Name</td>
+                <td>Type</td>
+                <td>Count(+)</td>
+                <td>Count(-)</td>
+                <td>Last used</td>
+            </tr>
+        </thead>`;
+        tagTable.id = "tac_tagUsageTable";
+
+        tagCounts.forEach((t) => {
+            let tr = document.createElement("tr");
+
+            // Fill values
+            let values = [t.name, t.type - 1, t.count, t.negCount, t.lastUseDate];
+            values.forEach((v) => {
+                let td = document.createElement("td");
+                td.innerText = v;
+                tr.append(td);
+            });
+            // Add delete/reset button
+            let delButton = document.createElement("button");
+            delButton.innerText = "🗑️";
+            delButton.title = "Reset count";
+            tr.append(delButton);
+
+            tagTable.append(tr);
+        });
+
+        return tagTable;
+    }
+
+    /**
+     * Sliding window function to get possible combination groups of an array
+     * @param {Array} inputArray
+     * @param {Number} size
+     * @returns {Array[]} ngram permutations of the input array
+     */
+    static toNgrams(inputArray, size) {
+        return Array.from(
+            { length: inputArray.length - (size - 1) }, //get the appropriate length
+            (_, index) => inputArray.slice(index, index + size) //create the windows
+        );
+    }
+
+    /**
+     * Escapes a string for use in a regular expression.
+     * @param {String} string
+     * @param {Boolean} wildcardMatching - Wildcard matching mode doesn't escape asterisks and question marks as they are handled separately there.
+     * @returns {String} The escaped string
+     */
+    static escapeRegExp(string, wildcardMatching = false) {
+        if (wildcardMatching) {
+            // Escape all characters except asterisks and ?, which should be treated separately as placeholders.
+            return string
+                .replace(/[-[\]{}()+.,\\^$|#\s]/g, "\\$&")
+                .replace(/\*/g, ".*")
+                .replace(/\?/g, ".");
+        }
+        return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
+    }
+    /**
+     * Escapes a string for use in HTML to not break formatting.
+     * @param {String} unsafeText
+     * @returns {String} The escaped HTML string
+     */
+    static escapeHTML(unsafeText) {
+        let div = document.createElement("div");
+        div.textContent = unsafeText;
+        return div.innerHTML;
+    }
+
+    /** Updates {@link TAC.Globals.currentModelName} to the current model */
+    static updateModelName() {
+        let sdm = gradioApp().querySelector("#setting_sd_model_checkpoint");
+        let modelDropdown = sdm?.querySelector("input") || sdm?.querySelector("select");
+        if (modelDropdown) {
+            TAC.Globals.currentModelName = modelDropdown.value;
+        } else {
+            // Fallback for intermediate versions
+            modelDropdown = sdm?.querySelector("span.single-select");
+            TAC.Globals.currentModelName = modelDropdown?.textContent || "";
+        }
+    }
+
+    /**
+     * From https://stackoverflow.com/a/61975440.
+     * Detects value changes in an element that were triggered programmatically
+     * @param {HTMLElement} element - The DOM element to observe
+     * @param {String} property - The object property to observe
+     * @param {Function} callback - The callback function to call when the property changes
+     * @param {Number} delay - The delay in milliseconds to wait before calling the callback
+     */
+    static observeElement(element, property, callback, delay = 0) {
+        let elementPrototype = Object.getPrototypeOf(element);
+        if (elementPrototype.hasOwnProperty(property)) {
+            let descriptor = Object.getOwnPropertyDescriptor(elementPrototype, property);
+            Object.defineProperty(element, property, {
+                get: function () {
+                    return descriptor.get.apply(this, arguments);
+                },
+                set: function () {
+                    let oldValue = this[property];
+                    descriptor.set.apply(this, arguments);
+                    let newValue = this[property];
+                    if (typeof callback == "function") {
+                        setTimeout(callback.bind(this, oldValue, newValue), delay);
+                    }
+                    return newValue;
+                },
+            });
+        }
+    }
+
+    /**
+     * Returns a matching sort function based on the current configuration
+     * @returns {((a: any, b: any) => number)}
+     */
+    static getSortFunction() {
+        let criterion = TAC.CFG.modelSortOrder || "Name";
+
+        const textSort = (a, b, reverse = false) => {
+            // Assign keys so next sort is faster
+            if (!a.sortKey) {
+                a.sortKey = a.type === TAC.ResultType.chant ? a.aliases : a.text;
+            }
+            if (!b.sortKey) {
+                b.sortKey = b.type === TAC.ResultType.chant ? b.aliases : b.text;
+            }
+
+            return reverse
+                ? b.sortKey.localeCompare(a.sortKey)
+                : a.sortKey.localeCompare(b.sortKey);
+        };
+        const numericSort = (a, b, reverse = false) => {
+            const noKey = reverse ? "-1" : Number.MAX_SAFE_INTEGER;
+            let aParsed = parseFloat(a.sortKey || noKey);
+            let bParsed = parseFloat(b.sortKey || noKey);
+
+            if (aParsed === bParsed) {
+                return textSort(a, b, false);
+            }
+
+            return reverse ? bParsed - aParsed : aParsed - bParsed;
+        };
+
+        return (a, b) => {
+            switch (criterion) {
+                case "Date Modified (newest first)":
+                    return numericSort(a, b, true);
+                case "Date Modified (oldest first)":
+                    return numericSort(a, b, false);
+                default:
+                    return textSort(a, b);
+            }
+        };
+    }
+
+    /**
+     * Queue calling function to process global queues
+     * @param {Array} queue - The queue to process
+     * @param {*} context - The context to call the functions in (null for global)
+     * @param  {...any} args - Arguments to pass to the functions
+     */
+    static async processQueue(queue, context, ...args) {
+        for (let i = 0; i < queue.length; i++) {
+            await queue[i].call(context, ...args);
+        }
+    }
+    /** The same as {@link processQueue}, but can accept and return results from the queued functions. */
+    static async processQueueReturn(queue, context, ...args) {
+        let qeueueReturns = [];
+        for (let i = 0; i < queue.length; i++) {
+            let returnValue = await queue[i].call(context, ...args);
+            if (returnValue) qeueueReturns.push(returnValue);
+        }
+        return qeueueReturns;
+    }
+    /**
+     * A queue processing function specific to tag completion parsers
+     * @param {HTMLTextAreaElement} textArea - The current text area used by TAC
+     * @param {String} prompt - The current prompt
+     * @returns The results of the parsers
+     */
+    static async processParsers(textArea, prompt) {
+        // Get all parsers that have a successful trigger condition
+        let matchingParsers = TAC.Ext.PARSERS.filter((parser) => parser.triggerCondition());
+        // Guard condition
+        if (matchingParsers.length === 0) {
+            return null;
+        }
+
+        let parseFunctions = matchingParsers.map((parser) => parser.parse);
+        // Process them and return the results
+        return await this.processQueueReturn(parseFunctions, null, textArea, prompt);
+    }
+};
--- a/javascript/ext_chants.js
+++ b/javascript/ext_chants.js
@@ -1,54 +1,66 @@
-const CHANT_REGEX = /<(?!e:|h:|l:)[^,> ]*>?/g;
-const CHANT_TRIGGER = () => TAC_CFG.chantFile && TAC_CFG.chantFile !== "None" && tagword.match(CHANT_REGEX);
+(function ChantExtension() {
+    const CHANT_REGEX = /<(?!e:|h:|l:)[^,> ]*>?/g;
+    const CHANT_TRIGGER = () =>
+        TAC.CFG.chantFile && TAC.CFG.chantFile !== "None" && TAC.Globals.tagword.match(CHANT_REGEX);

-class ChantParser extends BaseTagParser {
-    parse() {
-        // Show Chant
-        let tempResults = [];
-        if (tagword !== "<" && tagword !== "<c:") {
-            let searchTerm = tagword.replace("<chant:", "").replace("<c:", "").replace("<", "");
-            let filterCondition = x => x.terms.toLowerCase().includes(searchTerm) || x.name.toLowerCase().includes(searchTerm);
-            tempResults = chants.filter(x => filterCondition(x)); // Filter by tagword
+    class ChantParser extends TAC.BaseTagParser {
+        parse() {
+            // Show Chant
+            let tempResults = [];
+            if (TAC.Globals.tagword !== "<" && TAC.Globals.tagword !== "<c:") {
+                let searchTerm = TAC.Globals.tagword
+                    .replace("<chant:", "")
+                    .replace("<c:", "")
+                    .replace("<", "");
+                let filterCondition = (x) => {
+                    let regex = new RegExp(TAC.Utils.escapeRegExp(searchTerm, true), "i");
+                    return regex.test(x.terms.toLowerCase()) || regex.test(x.name.toLowerCase());
+                };
+                tempResults = TAC.Globals.chants.filter((x) => filterCondition(x)); // Filter by tagword
+            } else {
+                tempResults = TAC.Globals.chants;
+            }
+
+            // Add final results
+            let finalResults = [];
+            tempResults.forEach((t) => {
+                let result = new TAC.AutocompleteResult(t.content.trim(), TAC.ResultType.chant);
+                result.meta = "Chant";
+                result.aliases = t.name;
+                result.category = t.color;
+                finalResults.push(result);
+            });
+
+            return finalResults;
+        }
+    }
+
+    async function load() {
+        if (TAC.CFG.chantFile && TAC.CFG.chantFile !== "None") {
+            try {
+                TAC.Globals.chants = await TAC.Utils.readFile(
+                    `${TAC.Globals.tagBasePath}/${TAC.CFG.chantFile}?`,
+                    true
+                );
+            } catch (e) {
+                console.error("Error loading chants.json: " + e);
+            }
        } else {
-            tempResults = chants;
+            TAC.Globals.chants = [];
        }
-
-        // Add final results
-        let finalResults = [];
-        tempResults.forEach(t => {
-            let result = new AutocompleteResult(t.content.trim(), ResultType.chant)
-            result.meta = "Chant";
-            result.aliases = t.name;
-            result.category = t.color;
-            finalResults.push(result);
-        });
-
-        return finalResults;
    }
-}

-async function load() {
-    if (TAC_CFG.chantFile && TAC_CFG.chantFile !== "None") {
-        try {
-            chants = await readFile(`${tagBasePath}/${TAC_CFG.chantFile}?`, true);
-        } catch (e) {
-            console.error("Error loading chants.json: " + e);
+    function sanitize(tagType, text) {
+        if (tagType === TAC.ResultType.chant) {
+            return text;
        }
-    } else {
-        chants = [];
+        return null;
    }
-}

-function sanitize(tagType, text) {
-    if (tagType === ResultType.chant) {
-        return text.replace(/^.*?: /g, "");
-    }
-    return null;
-}
+    TAC.Ext.PARSERS.push(new ChantParser(CHANT_TRIGGER));

-PARSERS.push(new ChantParser(CHANT_TRIGGER));
-
-// Add our utility functions to their respective queues
-QUEUE_FILE_LOAD.push(load);
-QUEUE_SANITIZE.push(sanitize);
-QUEUE_AFTER_CONFIG_CHANGE.push(load);
+    // Add our utility functions to their respective queues
+    TAC.Ext.QUEUE_FILE_LOAD.push(load);
+    TAC.Ext.QUEUE_SANITIZE.push(sanitize);
+    TAC.Ext.QUEUE_AFTER_CONFIG_CHANGE.push(load);
+})();
--- a/javascript/ext_embeddings.js
+++ b/javascript/ext_embeddings.js
@@ -1,61 +1,85 @@
-const EMB_REGEX = /<(?!l:|h:|c:)[^,> ]*>?/g;
-const EMB_TRIGGER = () => TAC_CFG.useEmbeddings && tagword.match(EMB_REGEX);
+(function EmbeddingExtension() {
+    const EMB_REGEX = /<(?!l:|h:|c:)[^,> ]*>?/g;
+    const EMB_TRIGGER = () =>
+        TAC.CFG.useEmbeddings &&
+        (TAC.Globals.tagword.match(EMB_REGEX) || TAC.CFG.includeEmbeddingsInNormalResults);

-class EmbeddingParser extends BaseTagParser {
-    parse() {
-        // Show embeddings
-        let tempResults = [];
-        if (tagword !== "<" && tagword !== "<e:") {
-            let searchTerm = tagword.replace("<e:", "").replace("<", "");
-            let versionString;
-            if (searchTerm.startsWith("v1") || searchTerm.startsWith("v2")) {
-                versionString = searchTerm.slice(0, 2);
-                searchTerm = searchTerm.slice(2);
+    class EmbeddingParser extends TAC.BaseTagParser {
+        parse() {
+            // Show embeddings
+            let tempResults = [];
+            if (TAC.Globals.tagword !== "<" && TAC.Globals.tagword !== "<e:") {
+                let searchTerm = TAC.Globals.tagword.replace("<e:", "").replace("<", "");
+                let versionString;
+                if (searchTerm.startsWith("v1") || searchTerm.startsWith("v2")) {
+                    versionString = searchTerm.slice(0, 2);
+                    searchTerm = searchTerm.slice(2);
+                } else if (searchTerm.startsWith("vxl")) {
+                    versionString = searchTerm.slice(0, 3);
+                    searchTerm = searchTerm.slice(3);
+                }
+
+                let filterCondition = (x) => {
+                    let regex = new RegExp(TAC.Utils.escapeRegExp(searchTerm, true), "i");
+                    return (
+                        regex.test(x[0].toLowerCase()) ||
+                        regex.test(x[0].toLowerCase().replaceAll(" ", "_"))
+                    );
+                };
+
+                if (versionString)
+                    tempResults = TAC.Globals.embeddings.filter(
+                        (x) =>
+                            filterCondition(x) &&
+                            x[2] &&
+                            x[2].toLowerCase() === versionString.toLowerCase()
+                    ); // Filter by tagword
+                else tempResults = TAC.Globals.embeddings.filter((x) => filterCondition(x)); // Filter by tagword
+            } else {
+                tempResults = TAC.Globals.embeddings;
            }

-            let filterCondition = x => x[0].toLowerCase().includes(searchTerm) || x[0].toLowerCase().replaceAll(" ", "_").includes(searchTerm);
+            // Add final results
+            let finalResults = [];
+            tempResults.forEach((t) => {
+                let lastDot = t[0].lastIndexOf(".") > -1 ? t[0].lastIndexOf(".") : t[0].length;
+                let lastSlash = t[0].lastIndexOf("/") > -1 ? t[0].lastIndexOf("/") : -1;
+                let name = t[0].trim().substring(lastSlash + 1, lastDot);

-            if (versionString)
-                tempResults = embeddings.filter(x => filterCondition(x) && x[1] && x[1] === versionString); // Filter by tagword
-            else
-                tempResults = embeddings.filter(x => filterCondition(x)); // Filter by tagword
-        } else {
-            tempResults = embeddings;
-        }
+                let result = new TAC.AutocompleteResult(name, TAC.ResultType.embedding);
+                result.sortKey = t[1];
+                result.meta = t[2] + " Embedding";
+                finalResults.push(result);
+            });

-        // Add final results
-        let finalResults = [];
-        tempResults.forEach(t => {
-            let result = new AutocompleteResult(t[0].trim(), ResultType.embedding)
-            result.meta = t[1] + " Embedding";
-            finalResults.push(result);
-        });
-
-        return finalResults;
-    }
-}
-
-async function load() {
-    if (embeddings.length === 0) {
-        try {
-            embeddings = (await readFile(`${tagBasePath}/temp/emb.txt`)).split("\n")
-                .filter(x => x.trim().length > 0) // Remove empty lines
-                .map(x => x.trim().split(",")); // Split into name, version type pairs
-        } catch (e) {
-            console.error("Error loading embeddings.txt: " + e);
+            return finalResults;
        }
    }
-}

-function sanitize(tagType, text) {
-    if (tagType === ResultType.embedding) {
-        return text.replace(/^.*?: /g, "");
+    async function load() {
+        if (TAC.Globals.embeddings.length === 0) {
+            try {
+                TAC.Globals.embeddings = (
+                    await TAC.Utils.loadCSV(`${TAC.Globals.tagBasePath}/temp/emb.txt`)
+                )
+                    .filter((x) => x[0]?.trim().length > 0) // Remove empty lines
+                    .map((x) => [x[0].trim(), x[1], x[2]]); // Return name, sortKey, hash tuples
+            } catch (e) {
+                console.error("Error loading embeddings.txt: " + e);
+            }
+        }
    }
-    return null;
-}

-PARSERS.push(new EmbeddingParser(EMB_TRIGGER));
+    function sanitize(tagType, text) {
+        if (tagType === TAC.ResultType.embedding) {
+            return text;
+        }
+        return null;
+    }

-// Add our utility functions to their respective queues
-QUEUE_FILE_LOAD.push(load);
-QUEUE_SANITIZE.push(sanitize);
+    TAC.Ext.PARSERS.push(new EmbeddingParser(EMB_TRIGGER));
+
+    // Add our utility functions to their respective queues
+    TAC.Ext.QUEUE_FILE_LOAD.push(load);
+    TAC.Ext.QUEUE_SANITIZE.push(sanitize);
+})();
--- a/javascript/ext_hypernets.js
+++ b/javascript/ext_hypernets.js
@@ -1,51 +1,69 @@
-const HYP_REGEX = /<(?!e:|l:|c:)[^,> ]*>?/g;
-const HYP_TRIGGER = () => TAC_CFG.useHypernetworks && tagword.match(HYP_REGEX);
+(function HypernetExtension() {
+    const HYP_REGEX = /<(?!e:|l:|c:)[^,> ]*>?/g;
+    const HYP_TRIGGER = () => TAC.CFG.useHypernetworks && TAC.Globals.tagword.match(HYP_REGEX);

-class HypernetParser extends BaseTagParser {
-    parse() {
-        // Show hypernetworks
-        let tempResults = [];
-        if (tagword !== "<" && tagword !== "<h:" && tagword !== "<hypernet:") {
-            let searchTerm = tagword.replace("<hypernet:", "").replace("<h:", "").replace("<", "");
-            let filterCondition = x => x.toLowerCase().includes(searchTerm) || x.toLowerCase().replaceAll(" ", "_").includes(searchTerm);
-            tempResults = hypernetworks.filter(x => filterCondition(x)); // Filter by tagword
-        } else {
-            tempResults = hypernetworks;
-        }
+    class HypernetParser extends TAC.BaseTagParser {
+        parse() {
+            // Show hypernetworks
+            let tempResults = [];
+            if (
+                TAC.Globals.tagword !== "<" &&
+                TAC.Globals.tagword !== "<h:" &&
+                TAC.Globals.tagword !== "<hypernet:"
+            ) {
+                let searchTerm = TAC.Globals.tagword
+                    .replace("<hypernet:", "")
+                    .replace("<h:", "")
+                    .replace("<", "");
+                let filterCondition = (x) => {
+                    let regex = new RegExp(TAC.Utils.escapeRegExp(searchTerm, true), "i");
+                    return (
+                        regex.test(x.toLowerCase()) ||
+                        regex.test(x.toLowerCase().replaceAll(" ", "_"))
+                    );
+                };
+                tempResults = TAC.Globals.hypernetworks.filter((x) => filterCondition(x[0])); // Filter by tagword
+            } else {
+                tempResults = TAC.Globals.hypernetworks;
+            }

-        // Add final results
-        let finalResults = [];
-        tempResults.forEach(t => {
-            let result = new AutocompleteResult(t.trim(), ResultType.hypernetwork)
-            result.meta = "Hypernetwork";
-            finalResults.push(result);
-        });
+            // Add final results
+            let finalResults = [];
+            tempResults.forEach((t) => {
+                let result = new TAC.AutocompleteResult(t[0].trim(), TAC.ResultType.hypernetwork);
+                result.meta = "Hypernetwork";
+                result.sortKey = t[1];
+                finalResults.push(result);
+            });

-        return finalResults;
-    }
-}
-
-async function load() {
-    if (hypernetworks.length === 0) {
-        try {
-            hypernetworks = (await readFile(`${tagBasePath}/temp/hyp.txt`)).split("\n")
-                .filter(x => x.trim().length > 0) //Remove empty lines
-                .map(x => x.trim()); // Remove carriage returns and padding if it exists
-        } catch (e) {
-            console.error("Error loading hypernetworks.txt: " + e);
+            return finalResults;
        }
    }
-}

-function sanitize(tagType, text) {
-    if (tagType === ResultType.hypernetwork) {
-        return `<hypernet:${text}:${TAC_CFG.extraNetworksDefaultMultiplier}>`;
+    async function load() {
+        if (TAC.Globals.hypernetworks.length === 0) {
+            try {
+                TAC.Globals.hypernetworks = (
+                    await TAC.Utils.loadCSV(`${TAC.Globals.tagBasePath}/temp/hyp.txt`)
+                )
+                    .filter((x) => x[0]?.trim().length > 0) //Remove empty lines
+                    .map((x) => [x[0]?.trim(), x[1]]); // Remove carriage returns and padding if it exists
+            } catch (e) {
+                console.error("Error loading hypernetworks.txt: " + e);
+            }
+        }
    }
-    return null;
-}

-PARSERS.push(new HypernetParser(HYP_TRIGGER));
+    function sanitize(tagType, text) {
+        if (tagType === TAC.ResultType.hypernetwork) {
+            return `<hypernet:${text}:${TAC.CFG.extraNetworksDefaultMultiplier}>`;
+        }
+        return null;
+    }

-// Add our utility functions to their respective queues
-QUEUE_FILE_LOAD.push(load);
-QUEUE_SANITIZE.push(sanitize);
+    TAC.Ext.PARSERS.push(new HypernetParser(HYP_TRIGGER));
+
+    // Add our utility functions to their respective queues
+    TAC.Ext.QUEUE_FILE_LOAD.push(load);
+    TAC.Ext.QUEUE_SANITIZE.push(sanitize);
+})();
--- a/javascript/ext_loras.js
+++ b/javascript/ext_loras.js
@@ -1,51 +1,81 @@
-const LORA_REGEX = /<(?!e:|h:|c:)[^,> ]*>?/g;
-const LORA_TRIGGER = () => TAC_CFG.useLoras && tagword.match(LORA_REGEX);
+(function LoraExtension() {
+    const LORA_REGEX = /<(?!e:|h:|c:)[^,> ]*>?/g;
+    const LORA_TRIGGER = () => TAC.CFG.useLoras && TAC.Globals.tagword.match(LORA_REGEX);

-class LoraParser extends BaseTagParser {
-    parse() {
-        // Show lora
-        let tempResults = [];
-        if (tagword !== "<" && tagword !== "<l:" && tagword !== "<lora:") {
-            let searchTerm = tagword.replace("<lora:", "").replace("<l:", "").replace("<", "");
-            let filterCondition = x => x.toLowerCase().includes(searchTerm) || x.toLowerCase().replaceAll(" ", "_").includes(searchTerm);
-            tempResults = loras.filter(x => filterCondition(x)); // Filter by tagword
-        } else {
-            tempResults = loras;
-        }
+    class LoraParser extends TAC.BaseTagParser {
+        parse() {
+            // Show lora
+            let tempResults = [];
+            if (
+                TAC.Globals.tagword !== "<" &&
+                TAC.Globals.tagword !== "<l:" &&
+                TAC.Globals.tagword !== "<lora:"
+            ) {
+                let searchTerm = TAC.Globals.tagword
+                    .replace("<lora:", "")
+                    .replace("<l:", "")
+                    .replace("<", "");
+                let filterCondition = (x) => {
+                    let regex = new RegExp(TAC.Utils.escapeRegExp(searchTerm, true), "i");
+                    return (
+                        regex.test(x.toLowerCase()) ||
+                        regex.test(x.toLowerCase().replaceAll(" ", "_"))
+                    );
+                };
+                tempResults = TAC.Globals.loras.filter((x) => filterCondition(x[0])); // Filter by tagword
+            } else {
+                tempResults = TAC.Globals.loras;
+            }

-        // Add final results
-        let finalResults = [];
-        tempResults.forEach(t => {
-            let result = new AutocompleteResult(t.trim(), ResultType.lora)
-            result.meta = "Lora";
-            finalResults.push(result);
-        });
+            // Add final results
+            let finalResults = [];
+            tempResults.forEach((t) => {
+                const text = t[0].trim();
+                let lastDot = text.lastIndexOf(".") > -1 ? text.lastIndexOf(".") : text.length;
+                let lastSlash = text.lastIndexOf("/") > -1 ? text.lastIndexOf("/") : -1;
+                let name = text.substring(lastSlash + 1, lastDot);

-        return finalResults;
-    }
-}
+                let result = new TAC.AutocompleteResult(name, TAC.ResultType.lora);
+                result.meta = "Lora";
+                result.sortKey = t[1];
+                result.hash = t[2];
+                finalResults.push(result);
+            });

-async function load() {
-    if (loras.length === 0) {
-        try {
-            loras = (await readFile(`${tagBasePath}/temp/lora.txt`)).split("\n")
-                .filter(x => x.trim().length > 0) // Remove empty lines
-                .map(x => x.trim()); // Remove carriage returns and padding if it exists
-        } catch (e) {
-            console.error("Error loading lora.txt: " + e);
+            return finalResults;
        }
    }
-}

-function sanitize(tagType, text) {
-    if (tagType === ResultType.lora) {
-        return `<lora:${text}:${TAC_CFG.extraNetworksDefaultMultiplier}>`;
+    async function load() {
+        if (TAC.Globals.loras.length === 0) {
+            try {
+                TAC.Globals.loras = (
+                    await TAC.Utils.loadCSV(`${TAC.Globals.tagBasePath}/temp/lora.txt`)
+                )
+                    .filter((x) => x[0]?.trim().length > 0) // Remove empty lines
+                    .map((x) => [x[0]?.trim(), x[1], x[2]]); // Trim filenames and return the name, sortKey, hash pairs
+            } catch (e) {
+                console.error("Error loading lora.txt: " + e);
+            }
+        }
    }
-    return null;
-}

-PARSERS.push(new LoraParser(LORA_TRIGGER));
+    async function sanitize(tagType, text) {
+        if (tagType === TAC.ResultType.lora) {
+            let multiplier = TAC.CFG.extraNetworksDefaultMultiplier;
+            let info = await TAC.Utils.fetchAPI(`tacapi/v1/lora-info/${text}`);
+            if (info && info["preferred weight"]) {
+                multiplier = info["preferred weight"];
+            }

-// Add our utility functions to their respective queues
-QUEUE_FILE_LOAD.push(load);
-QUEUE_SANITIZE.push(sanitize);
+            return `<lora:${text}:${multiplier}>`;
+        }
+        return null;
+    }
+
+    TAC.Ext.PARSERS.push(new LoraParser(LORA_TRIGGER));
+
+    // Add our utility functions to their respective queues
+    TAC.Ext.QUEUE_FILE_LOAD.push(load);
+    TAC.Ext.QUEUE_SANITIZE.push(sanitize);
+})();
--- a/javascript/ext_lycos.js
+++ b/javascript/ext_lycos.js
@@ -1,51 +1,84 @@
-const LYCO_REGEX = /<(?!e:|h:|c:)[^,> ]*>?/g;
-const LYCO_TRIGGER = () => TAC_CFG.useLycos && tagword.match(LYCO_REGEX);
+(function LycoExtension() {
+    const LYCO_REGEX = /<(?!e:|h:|c:)[^,> ]*>?/g;
+    const LYCO_TRIGGER = () => TAC.CFG.useLycos && TAC.Globals.tagword.match(LYCO_REGEX);

-class LycoParser extends BaseTagParser {
-    parse() {
-        // Show lyco
-        let tempResults = [];
-        if (tagword !== "<" && tagword !== "<l:" && tagword !== "<lyco:") {
-            let searchTerm = tagword.replace("<lyco:", "").replace("<l:", "").replace("<", "");
-            let filterCondition = x => x.toLowerCase().includes(searchTerm) || x.toLowerCase().replaceAll(" ", "_").includes(searchTerm);
-            tempResults = lycos.filter(x => filterCondition(x)); // Filter by tagword
-        } else {
-            tempResults = lycos;
-        }
+    class LycoParser extends TAC.BaseTagParser {
+        parse() {
+            // Show lyco
+            let tempResults = [];
+            if (
+                TAC.Globals.tagword !== "<" &&
+                TAC.Globals.tagword !== "<l:" &&
+                TAC.Globals.tagword !== "<lyco:" &&
+                TAC.Globals.tagword !== "<lora:"
+            ) {
+                let searchTerm = TAC.Globals.tagword
+                    .replace("<lyco:", "")
+                    .replace("<lora:", "")
+                    .replace("<l:", "")
+                    .replace("<", "");
+                let filterCondition = (x) => {
+                    let regex = new RegExp(TAC.Utils.escapeRegExp(searchTerm, true), "i");
+                    return (
+                        regex.test(x.toLowerCase()) ||
+                        regex.test(x.toLowerCase().replaceAll(" ", "_"))
+                    );
+                };
+                tempResults = TAC.Globals.lycos.filter((x) => filterCondition(x[0])); // Filter by tagword
+            } else {
+                tempResults = TAC.Globals.lycos;
+            }

-        // Add final results
-        let finalResults = [];
-        tempResults.forEach(t => {
-            let result = new AutocompleteResult(t.trim(), ResultType.lyco)
-            result.meta = "Lyco";
-            finalResults.push(result);
-        });
+            // Add final results
+            let finalResults = [];
+            tempResults.forEach((t) => {
+                const text = t[0].trim();
+                let lastDot = text.lastIndexOf(".") > -1 ? text.lastIndexOf(".") : text.length;
+                let lastSlash = text.lastIndexOf("/") > -1 ? text.lastIndexOf("/") : -1;
+                let name = text.substring(lastSlash + 1, lastDot);

-        return finalResults;
-    }
-}
+                let result = new TAC.AutocompleteResult(name, TAC.ResultType.lyco);
+                result.meta = "Lyco";
+                result.sortKey = t[1];
+                result.hash = t[2];
+                finalResults.push(result);
+            });

-async function load() {
-    if (lycos.length === 0) {
-        try {
-            lycos = (await readFile(`${tagBasePath}/temp/lyco.txt`)).split("\n")
-                .filter(x => x.trim().length > 0) // Remove empty lines
-                .map(x => x.trim()); // Remove carriage returns and padding if it exists
-        } catch (e) {
-            console.error("Error loading lyco.txt: " + e);
+            return finalResults;
        }
    }
-}

-function sanitize(tagType, text) {
-    if (tagType === ResultType.lyco) {
-        return `<lyco:${text}:${TAC_CFG.extraNetworksDefaultMultiplier}>`;
+    async function load() {
+        if (TAC.Globals.lycos.length === 0) {
+            try {
+                TAC.Globals.lycos = (
+                    await TAC.Utils.loadCSV(`${TAC.Globals.tagBasePath}/temp/lyco.txt`)
+                )
+                    .filter((x) => x[0]?.trim().length > 0) // Remove empty lines
+                    .map((x) => [x[0]?.trim(), x[1], x[2]]); // Trim filenames and return the name, sortKey, hash pairs
+            } catch (e) {
+                console.error("Error loading lyco.txt: " + e);
+            }
+        }
    }
-    return null;
-}

-PARSERS.push(new LycoParser(LYCO_TRIGGER));
+    async function sanitize(tagType, text) {
+        if (tagType === TAC.ResultType.lyco) {
+            let multiplier = TAC.CFG.extraNetworksDefaultMultiplier;
+            let info = await TAC.Utils.fetchAPI(`tacapi/v1/lyco-info/${text}`);
+            if (info && info["preferred weight"]) {
+                multiplier = info["preferred weight"];
+            }

-// Add our utility functions to their respective queues
-QUEUE_FILE_LOAD.push(load);
-QUEUE_SANITIZE.push(sanitize);
+            let prefix = TAC.CFG.useLoraPrefixForLycos ? "lora" : "lyco";
+            return `<${prefix}:${text}:${multiplier}>`;
+        }
+        return null;
+    }
+
+    TAC.Ext.PARSERS.push(new LycoParser(LYCO_TRIGGER));
+
+    // Add our utility functions to their respective queues
+    TAC.Ext.QUEUE_FILE_LOAD.push(load);
+    TAC.Ext.QUEUE_SANITIZE.push(sanitize);
+})();
--- a/javascript/ext_modelKeyword.js
+++ b/javascript/ext_modelKeyword.js
@@ -0,0 +1,56 @@
+(function ModelKeywordExtension() {
+    async function load() {
+        let modelKeywordParts = (await TAC.Utils.readFile(`tmp/modelKeywordPath.txt`)).split(",");
+        TAC.Globals.modelKeywordPath = modelKeywordParts[0];
+        let customFileExists = modelKeywordParts[1] === "True";
+
+        if (TAC.Globals.modelKeywordPath.length > 0 && TAC.Globals.modelKeywordDict.size === 0) {
+            try {
+                let csv_lines = [];
+                // Only add default keywords if wanted by the user
+                if (TAC.CFG.modelKeywordCompletion !== "Only user list")
+                    csv_lines = await TAC.Utils.loadCSV(
+                        `${TAC.Globals.modelKeywordPath}/lora-keyword.txt`
+                    );
+                // Add custom user keywords if the file exists
+                if (customFileExists)
+                    csv_lines = csv_lines.concat(
+                        await TAC.Utils.loadCSV(
+                            `${TAC.Globals.modelKeywordPath}/lora-keyword-user.txt`
+                        )
+                    );
+
+                if (csv_lines.length === 0) return;
+
+                csv_lines = csv_lines.filter(
+                    (x) => x[0].trim().length > 0 && x[0].trim()[0] !== "#"
+                ); // Remove empty lines and comments
+
+                // Add to the dict
+                csv_lines.forEach((parts) => {
+                    const hash = parts[0];
+                    const keywords = parts[1]
+                        ?.replaceAll("| ", ", ")
+                        ?.replaceAll("|", ", ")
+                        ?.trim();
+                    const lastSepIndex =
+                        parts[2]?.lastIndexOf("/") + 1 || parts[2]?.lastIndexOf("\\") + 1 || 0;
+                    const name = parts[2]?.substring(lastSepIndex).trim() || "none";
+
+                    if (TAC.Globals.modelKeywordDict.has(hash) && name !== "none") {
+                        // Add a new name key if the hash already exists
+                        TAC.Globals.modelKeywordDict.get(hash).set(name, keywords);
+                    } else {
+                        // Create new hash entry
+                        let map = new Map().set(name, keywords);
+                        TAC.Globals.modelKeywordDict.set(hash, map);
+                    }
+                });
+            } catch (e) {
+                console.error("Error loading model-keywords list: " + e);
+            }
+        }
+    }
+
+    TAC.Ext.QUEUE_FILE_LOAD.push(load);
+})();
--- a/javascript/ext_styles.js
+++ b/javascript/ext_styles.js
@@ -0,0 +1,77 @@
+(function StyleExtension() {
+    const STYLE_REGEX = /(\$(\d*)\(?)[^$|\[\],\s]*\)?/;
+    const STYLE_TRIGGER = () => TAC.CFG.useStyleVars && TAC.Globals.tagword.match(STYLE_REGEX);
+
+    var lastStyleVarIndex = "";
+
+    class StyleParser extends TAC.BaseTagParser {
+        async parse() {
+            // Refresh if needed
+            await TAC.Utils.refreshStyleNamesIfChanged();
+
+            // Show styles
+            let tempResults = [];
+            let matchGroups = TAC.Globals.tagword.match(STYLE_REGEX);
+
+            // Save index to insert again later or clear last one
+            lastStyleVarIndex = matchGroups[2] ? matchGroups[2] : "";
+
+            if (TAC.Globals.tagword !== matchGroups[1]) {
+                let searchTerm = TAC.Globals.tagword.replace(matchGroups[1], "");
+
+                let filterCondition = (x) => {
+                    let regex = new RegExp(TAC.Utils.escapeRegExp(searchTerm, true), "i");
+                    return (
+                        regex.test(x[0].toLowerCase()) ||
+                        regex.test(x[0].toLowerCase().replaceAll(" ", "_"))
+                    );
+                };
+                tempResults = TAC.Globals.styleNames.filter((x) => filterCondition(x)); // Filter by tagword
+            } else {
+                tempResults = TAC.Globals.styleNames;
+            }
+
+            // Add final results
+            let finalResults = [];
+            tempResults.forEach((t) => {
+                let result = new TAC.AutocompleteResult(t[0].trim(), TAC.ResultType.styleName);
+                result.meta = "Style";
+                finalResults.push(result);
+            });
+
+            return finalResults;
+        }
+    }
+
+    async function load(force = false) {
+        if (TAC.Globals.styleNames.length === 0 || force) {
+            try {
+                TAC.Globals.styleNames = (
+                    await TAC.Utils.loadCSV(`${TAC.Globals.tagBasePath}/temp/styles.txt`)
+                )
+                    .filter((x) => x[0]?.trim().length > 0) // Remove empty lines
+                    .filter((x) => x[0] !== "None") // Remove "None" style
+                    .map((x) => [x[0].trim()]); // Trim name
+            } catch (e) {
+                console.error("Error loading styles.txt: " + e);
+            }
+        }
+    }
+
+    function sanitize(tagType, text) {
+        if (tagType === TAC.ResultType.styleName) {
+            if (text.includes(" ")) {
+                return `$${lastStyleVarIndex}(${text})`;
+            } else {
+                return `$${lastStyleVarIndex}${text}`;
+            }
+        }
+        return null;
+    }
+
+    TAC.Ext.PARSERS.push(new StyleParser(STYLE_TRIGGER));
+
+    // Add our utility functions to their respective queues
+    TAC.Ext.QUEUE_FILE_LOAD.push(load);
+    TAC.Ext.QUEUE_SANITIZE.push(sanitize);
+})();
--- a/javascript/ext_umi.js
+++ b/javascript/ext_umi.js
@@ -1,240 +1,279 @@
-const UMI_PROMPT_REGEX = /<[^\s]*?\[[^,<>]*[\]|]?>?/gi;
-const UMI_TAG_REGEX = /(?:\[|\||--)([^<>\[\]\-|]+)/gi;
+(function UmiExtension() {
+    const UMI_PROMPT_REGEX = /<[^\s]*?\[[^,<>]*[\]|]?>?/gi;
+    const UMI_TAG_REGEX = /(?:\[|\||--)([^<>\[\]\-|]+)/gi;

-const UMI_TRIGGER = () => TAC_CFG.useWildcards && [...tagword.matchAll(UMI_PROMPT_REGEX)].length > 0;
+    const UMI_TRIGGER = () =>
+        TAC.CFG.useWildcards && [...TAC.Globals.tagword.matchAll(UMI_PROMPT_REGEX)].length > 0;

-class UmiParser extends BaseTagParser {
-    parse(textArea, prompt) {
-        // We are in a UMI yaml tag definition, parse further
-        let umiSubPrompts = [...prompt.matchAll(UMI_PROMPT_REGEX)];
-                
-        let umiTags = [];
-        let umiTagsWithOperators = []
+    class UmiParser extends TAC.BaseTagParser {
+        parse(textArea, prompt) {
+            // We are in a UMI yaml tag definition, parse further
+            let umiSubPrompts = [...prompt.matchAll(UMI_PROMPT_REGEX)];

-        const insertAt = (str,char,pos) => str.slice(0,pos) + char + str.slice(pos);
+            let umiTags = [];
+            let umiTagsWithOperators = [];

-        umiSubPrompts.forEach(umiSubPrompt => {
-            umiTags = umiTags.concat([...umiSubPrompt[0].matchAll(UMI_TAG_REGEX)].map(x => x[1].toLowerCase()));
-            
-            const start = umiSubPrompt.index;
-            const end = umiSubPrompt.index + umiSubPrompt[0].length;
-            if (textArea.selectionStart >= start && textArea.selectionStart <= end) {
-                umiTagsWithOperators = insertAt(umiSubPrompt[0], '###', textArea.selectionStart - start);
-            }
-        });
+            const insertAt = (str, char, pos) => str.slice(0, pos) + char + str.slice(pos);

-        // Safety check since UMI parsing sometimes seems to trigger outside of an UMI subprompt and thus fails
-        if (umiTagsWithOperators.length === 0) {
-            return null;
-        }
-
-        const promptSplitToTags = umiTagsWithOperators.replace(']###[', '][').split("][");
-
-        const clean = (str) => str
-            .replaceAll('>', '')
-            .replaceAll('<', '')
-            .replaceAll('[', '')
-            .replaceAll(']', '')
-            .trim();
-
-        const matches = promptSplitToTags.reduce((acc, curr) => {
-            let isOptional = curr.includes("|");
-            let isNegative = curr.startsWith("--");
-            let out;
-            if (isOptional) {
-                out = {
-                    hasCursor: curr.includes("###"),
-                    tags: clean(curr).split('|').map(x => ({ 
-                        hasCursor: x.includes("###"), 
-                        isNegative: x.startsWith("--"),
-                        tag: clean(x).replaceAll("###", '').replaceAll("--", '')
-                    }))
-                };
-                acc.optional.push(out);
-                acc.all.push(...out.tags.map(x => x.tag));
-            } else if (isNegative) {
-                out = {
-                    hasCursor: curr.includes("###"),
-                    tags: clean(curr).replaceAll("###", '').split('|'),
-                };
-                out.tags = out.tags.map(x => x.startsWith("--") ? x.substring(2) : x);
-                acc.negative.push(out);
-                acc.all.push(...out.tags);
-            } else {
-                out = {
-                    hasCursor: curr.includes("###"),
-                    tags: clean(curr).replaceAll("###", '').split('|'),
-                };
-                acc.positive.push(out);
-                acc.all.push(...out.tags);
-            }
-            return acc;
-        }, { positive: [], negative: [], optional: [], all: [] });
-
-        //console.log({ matches })
-
-        const filteredWildcards = (tagword) => {
-            const wildcards = yamlWildcards.filter(x => {
-                let tags = x[1];
-                const matchesNeg =
-                    matches.negative.length === 0
-                    || matches.negative.every(x => 
-                        x.hasCursor 
-                        || x.tags.every(t => !tags[t])
-                    );
-                if (!matchesNeg) return false;
-                const matchesPos =
-                    matches.positive.length === 0
-                    || matches.positive.every(x =>
-                        x.hasCursor
-                        || x.tags.every(t => tags[t])
-                    );
-                if (!matchesPos) return false;
-                const matchesOpt =
-                    matches.optional.length === 0
-                    || matches.optional.some(x =>
-                        x.tags.some(t =>
-                            t.hasCursor
-                            || t.isNegative
-                                ? !tags[t.tag]
-                                : tags[t.tag]
-                    ));
-                if (!matchesOpt) return false;
-                return true;
-            }).reduce((acc, val) => {
-                Object.keys(val[1]).forEach(tag => acc[tag] = acc[tag] + 1 || 1);
-                return acc;
-            }, {});
-
-            return Object.entries(wildcards)
-                .sort((a, b) => b[1] - a[1])
-                .filter(x =>
-                    x[0] === tagword
-                    || !matches.all.includes(x[0])
+            umiSubPrompts.forEach((umiSubPrompt) => {
+                umiTags = umiTags.concat(
+                    [...umiSubPrompt[0].matchAll(UMI_TAG_REGEX)].map((x) => x[1].toLowerCase())
                );
-        }
-        
-        if (umiTags.length > 0) {
-            // Get difference for subprompt
-            let tagCountChange = umiTags.length - umiPreviousTags.length;
-            let diff = difference(umiTags, umiPreviousTags);
-            umiPreviousTags = umiTags;

-            // Show all condition
-            let showAll = tagword.endsWith("[") || tagword.endsWith("[--") || tagword.endsWith("|");
-
-            // Exit early if the user closed the bracket manually
-            if ((!diff || diff.length === 0 || (diff.length === 1 && tagCountChange < 0)) && !showAll) {
-                if (!hideBlocked) hideResults(textArea);
-                return;
-            }
-
-            let umiTagword = diff[0] || '';
-            let tempResults = [];
-            if (umiTagword && umiTagword.length > 0) {
-                umiTagword = umiTagword.toLowerCase().replace(/[\n\r]/g, "");
-                originalTagword = tagword;
-                tagword = umiTagword;
-                let filteredWildcardsSorted = filteredWildcards(umiTagword);
-                let searchRegex = new RegExp(`(^|[^a-zA-Z])${escapeRegExp(umiTagword)}`, 'i')
-                let baseFilter = x => x[0].toLowerCase().search(searchRegex) > -1;
-                let spaceIncludeFilter = x => x[0].toLowerCase().replaceAll(" ", "_").search(searchRegex) > -1;
-                tempResults = filteredWildcardsSorted.filter(x => baseFilter(x) || spaceIncludeFilter(x)) // Filter by tagword
-
-                // Add final results
-                let finalResults = [];
-                tempResults.forEach(t => {
-                    let result = new AutocompleteResult(t[0].trim(), ResultType.yamlWildcard)
-                    result.count = t[1];
-                    finalResults.push(result);
-                });
-
-                return finalResults;
-            } else if (showAll) {
-                let filteredWildcardsSorted = filteredWildcards("");
-                
-                // Add final results
-                let finalResults = [];
-                filteredWildcardsSorted.forEach(t => {
-                    let result = new AutocompleteResult(t[0].trim(), ResultType.yamlWildcard)
-                    result.count = t[1];
-                    finalResults.push(result);
-                });
-        
-                originalTagword = tagword;
-                tagword = "";
-                return finalResults;
-            }
-        } else {
-            let filteredWildcardsSorted = filteredWildcards("");
-                
-            // Add final results
-            let finalResults = [];
-            filteredWildcardsSorted.forEach(t => {
-                let result = new AutocompleteResult(t[0].trim(), ResultType.yamlWildcard)
-                result.count = t[1];
-                finalResults.push(result);
+                const start = umiSubPrompt.index;
+                const end = umiSubPrompt.index + umiSubPrompt[0].length;
+                if (textArea.selectionStart >= start && textArea.selectionStart <= end) {
+                    umiTagsWithOperators = insertAt(
+                        umiSubPrompt[0],
+                        "###",
+                        textArea.selectionStart - start
+                    );
+                }
            });

-            originalTagword = tagword;
-            tagword = "";
-            return finalResults;
+            // Safety check since UMI parsing sometimes seems to trigger outside of an UMI subprompt and thus fails
+            if (umiTagsWithOperators.length === 0) {
+                return null;
+            }
+
+            const promptSplitToTags = umiTagsWithOperators.replace("]###[", "][").split("][");
+
+            const clean = (str) =>
+                str
+                    .replaceAll(">", "")
+                    .replaceAll("<", "")
+                    .replaceAll("[", "")
+                    .replaceAll("]", "")
+                    .trim();
+
+            const matches = promptSplitToTags.reduce(
+                (acc, curr) => {
+                    let isOptional = curr.includes("|");
+                    let isNegative = curr.startsWith("--");
+                    let out;
+                    if (isOptional) {
+                        out = {
+                            hasCursor: curr.includes("###"),
+                            tags: clean(curr)
+                                .split("|")
+                                .map((x) => ({
+                                    hasCursor: x.includes("###"),
+                                    isNegative: x.startsWith("--"),
+                                    tag: clean(x).replaceAll("###", "").replaceAll("--", ""),
+                                })),
+                        };
+                        acc.optional.push(out);
+                        acc.all.push(...out.tags.map((x) => x.tag));
+                    } else if (isNegative) {
+                        out = {
+                            hasCursor: curr.includes("###"),
+                            tags: clean(curr).replaceAll("###", "").split("|"),
+                        };
+                        out.tags = out.tags.map((x) => (x.startsWith("--") ? x.substring(2) : x));
+                        acc.negative.push(out);
+                        acc.all.push(...out.tags);
+                    } else {
+                        out = {
+                            hasCursor: curr.includes("###"),
+                            tags: clean(curr).replaceAll("###", "").split("|"),
+                        };
+                        acc.positive.push(out);
+                        acc.all.push(...out.tags);
+                    }
+                    return acc;
+                },
+                { positive: [], negative: [], optional: [], all: [] }
+            );
+
+            //console.log({ matches })
+
+            const filteredWildcards = (tagword) => {
+                const wildcards = TAC.Globals.umiWildcards
+                    .filter((x) => {
+                        let tags = x[1];
+                        const matchesNeg =
+                            matches.negative.length === 0 ||
+                            matches.negative.every(
+                                (x) => x.hasCursor || x.tags.every((t) => !tags[t])
+                            );
+                        if (!matchesNeg) return false;
+                        const matchesPos =
+                            matches.positive.length === 0 ||
+                            matches.positive.every(
+                                (x) => x.hasCursor || x.tags.every((t) => tags[t])
+                            );
+                        if (!matchesPos) return false;
+                        const matchesOpt =
+                            matches.optional.length === 0 ||
+                            matches.optional.some((x) =>
+                                x.tags.some((t) =>
+                                    t.hasCursor || t.isNegative ? !tags[t.tag] : tags[t.tag]
+                                )
+                            );
+                        if (!matchesOpt) return false;
+                        return true;
+                    })
+                    .reduce((acc, val) => {
+                        Object.keys(val[1]).forEach((tag) => (acc[tag] = acc[tag] + 1 || 1));
+                        return acc;
+                    }, {});
+
+                return Object.entries(wildcards)
+                    .sort((a, b) => b[1] - a[1])
+                    .filter((x) => x[0] === tagword || !matches.all.includes(x[0]));
+            };
+
+            if (umiTags.length > 0) {
+                // Get difference for subprompt
+                let tagCountChange = umiTags.length - TAC.Globals.umiPreviousTags.length;
+                let diff = TAC.Utils.difference(umiTags, TAC.Globals.umiPreviousTags);
+                TAC.Globals.umiPreviousTags = umiTags;
+
+                // Show all condition
+                let showAll =
+                    TAC.Globals.tagword.endsWith("[") ||
+                    TAC.Globals.tagword.endsWith("[--") ||
+                    TAC.Globals.tagword.endsWith("|");
+
+                // Exit early if the user closed the bracket manually
+                if (
+                    (!diff || diff.length === 0 || (diff.length === 1 && tagCountChange < 0)) &&
+                    !showAll
+                ) {
+                    if (!TAC.Globals.hideBlocked) hideResults(textArea);
+                    return;
+                }
+
+                let umiTagword = tagCountChange < 0 ? "" : diff[0] || "";
+                let tempResults = [];
+                if (umiTagword && umiTagword.length > 0) {
+                    umiTagword = umiTagword.toLowerCase().replace(/[\n\r]/g, "");
+                    TAC.Globals.originalTagword = TAC.Globals.tagword;
+                    TAC.Globals.tagword = umiTagword;
+                    let filteredWildcardsSorted = filteredWildcards(umiTagword);
+                    let searchRegex = new RegExp(
+                        `(^|[^a-zA-Z])${TAC.Utils.escapeRegExp(umiTagword)}`,
+                        "i"
+                    );
+                    let baseFilter = (x) => x[0].toLowerCase().search(searchRegex) > -1;
+                    let spaceIncludeFilter = (x) =>
+                        x[0].toLowerCase().replaceAll(" ", "_").search(searchRegex) > -1;
+                    tempResults = filteredWildcardsSorted.filter(
+                        (x) => baseFilter(x) || spaceIncludeFilter(x)
+                    ); // Filter by tagword
+
+                    // Add final results
+                    let finalResults = [];
+                    tempResults.forEach((t) => {
+                        let result = new TAC.AutocompleteResult(
+                            t[0].trim(),
+                            TAC.ResultType.umiWildcard
+                        );
+                        result.count = t[1];
+                        finalResults.push(result);
+                    });
+
+                    finalResults = finalResults.sort((a, b) => b.count - a.count);
+                    return finalResults;
+                } else if (showAll) {
+                    let filteredWildcardsSorted = filteredWildcards("");
+
+                    // Add final results
+                    let finalResults = [];
+                    filteredWildcardsSorted.forEach((t) => {
+                        let result = new TAC.AutocompleteResult(
+                            t[0].trim(),
+                            TAC.ResultType.umiWildcard
+                        );
+                        result.count = t[1];
+                        finalResults.push(result);
+                    });
+
+                    TAC.Globals.originalTagword = TAC.Globals.tagword;
+                    TAC.Globals.tagword = "";
+
+                    finalResults = finalResults.sort((a, b) => b.count - a.count);
+                    return finalResults;
+                }
+            } else {
+                let filteredWildcardsSorted = filteredWildcards("");
+
+                // Add final results
+                let finalResults = [];
+                filteredWildcardsSorted.forEach((t) => {
+                    let result = new TAC.AutocompleteResult(
+                        t[0].trim(),
+                        TAC.ResultType.umiWildcard
+                    );
+                    result.count = t[1];
+                    finalResults.push(result);
+                });
+
+                TAC.Globals.originalTagword = TAC.Globals.tagword;
+                TAC.Globals.tagword = "";
+
+                finalResults = finalResults.sort((a, b) => b.count - a.count);
+                return finalResults;
+            }
        }
    }
-}

-function updateUmiTags( tagType, sanitizedText, newPrompt, textArea) {
-    // If it was a yaml wildcard, also update the umiPreviousTags
-    if (tagType === ResultType.yamlWildcard && originalTagword.length > 0) {
-        let umiSubPrompts = [...newPrompt.matchAll(UMI_PROMPT_REGEX)];
+    function updateUmiTags(tagType, sanitizedText, newPrompt, textArea) {
+        // If it was a umi wildcard, also update the TAC.Globals.umiPreviousTags
+        if (tagType === TAC.ResultType.umiWildcard && TAC.Globals.originalTagword.length > 0) {
+            let umiSubPrompts = [...newPrompt.matchAll(UMI_PROMPT_REGEX)];

-        let umiTags = [];
-        umiSubPrompts.forEach(umiSubPrompt => {
-            umiTags = umiTags.concat([...umiSubPrompt[0].matchAll(UMI_TAG_REGEX)].map(x => x[1].toLowerCase()));
-        });
+            let umiTags = [];
+            umiSubPrompts.forEach((umiSubPrompt) => {
+                umiTags = umiTags.concat(
+                    [...umiSubPrompt[0].matchAll(UMI_TAG_REGEX)].map((x) => x[1].toLowerCase())
+                );
+            });

-        umiPreviousTags = umiTags;
+            TAC.Globals.umiPreviousTags = umiTags;

-        hideResults(textArea);
+            hideResults(textArea);

-        return true;
+            return true;
+        }
+        return false;
    }
-    return false;
-}

-async function load() {
-    if (yamlWildcards.length === 0) {
-        try {
-            let yamlTags = (await readFile(`${tagBasePath}/temp/wcet.txt`)).split("\n");
-            // Split into tag, count pairs
-            yamlWildcards = yamlTags.map(x => x
-                .trim()
-                .split(","))
-                .map(([i, ...rest]) => [
-                    i,
-                    rest.reduce((a, b) => {
-                        a[b.toLowerCase()] = true;
-                        return a;
-                    }, {}),
-                ]);
-        } catch (e) {
-            console.error("Error loading yaml wildcards: " + e);
+    async function load() {
+        if (TAC.Globals.umiWildcards.length === 0) {
+            try {
+                let umiTags = (
+                    await TAC.Utils.readFile(`${TAC.Globals.tagBasePath}/temp/umi_tags.txt`)
+                ).split("\n");
+                // Split into tag, count pairs
+                TAC.Globals.umiWildcards = umiTags
+                    .map((x) => x.trim().split(","))
+                    .map(([i, ...rest]) => [
+                        i,
+                        rest.reduce((a, b) => {
+                            a[b.toLowerCase()] = true;
+                            return a;
+                        }, {}),
+                    ]);
+            } catch (e) {
+                console.error("Error loading umi wildcards: " + e);
+            }
        }
    }
-}

-function sanitize(tagType, text) {
-    // Replace underscores only if the yaml tag is not using them
-    if (tagType === ResultType.yamlWildcard && !yamlWildcards.includes(text)) {
-        return text.replaceAll("_", " "); 
+    function sanitize(tagType, text) {
+        // Replace underscores only if the umi tag is not using them
+        if (tagType === TAC.ResultType.umiWildcard && !TAC.Globals.umiWildcards.includes(text)) {
+            return text.replaceAll("_", " ");
+        }
+        return null;
    }
-    return null;
-}

-// Add UMI parser
-PARSERS.push(new UmiParser(UMI_TRIGGER));
+    // Add UMI parser
+    TAC.Ext.PARSERS.push(new UmiParser(UMI_TRIGGER));

-// Add our utility functions to their respective queues
-QUEUE_FILE_LOAD.push(load);
-QUEUE_SANITIZE.push(sanitize);
-QUEUE_AFTER_INSERT.push(updateUmiTags);
+    // Add our utility functions to their respective queues
+    TAC.Ext.QUEUE_FILE_LOAD.push(load);
+    TAC.Ext.QUEUE_SANITIZE.push(sanitize);
+    TAC.Ext.QUEUE_AFTER_INSERT.push(updateUmiTags);
+})();
--- a/javascript/ext_wildcards.js
+++ b/javascript/ext_wildcards.js
@@ -1,123 +1,232 @@
-// Regex
-const WC_REGEX = /\b__([^,]+)__([^, ]*)\b/g;
+(function WildcardExtension() {
+    // Regex
+    const WC_REGEX = new RegExp(/__([^,]+)__([^, ]*)/g);

-// Trigger conditions
-const WC_TRIGGER = () => TAC_CFG.useWildcards && [...tagword.matchAll(WC_REGEX)].length > 0;
-const WC_FILE_TRIGGER = () => TAC_CFG.useWildcards && (tagword.startsWith("__") && !tagword.endsWith("__") || tagword === "__");
+    // Trigger conditions
+    const WC_TRIGGER = () =>
+        TAC.CFG.useWildcards &&
+        [
+            ...TAC.Globals.tagword.matchAll(
+                new RegExp(
+                    WC_REGEX.source.replaceAll("__", TAC.Utils.escapeRegExp(TAC.CFG.wcWrap)),
+                    "g"
+                )
+            ),
+        ].length > 0;
+    const WC_FILE_TRIGGER = () =>
+        TAC.CFG.useWildcards &&
+        ((TAC.Globals.tagword.startsWith(TAC.CFG.wcWrap) &&
+            !TAC.Globals.tagword.endsWith(TAC.CFG.wcWrap)) ||
+            TAC.Globals.tagword === TAC.CFG.wcWrap);

-class WildcardParser extends BaseTagParser {
-    async parse() {
-        // Show wildcards from a file with that name
-        let wcMatch = [...tagword.matchAll(WC_REGEX)]
-        let wcFile = wcMatch[0][1];
-        let wcWord = wcMatch[0][2];
+    class WildcardParser extends TAC.BaseTagParser {
+        async parse() {
+            // Show wildcards from a file with that name
+            let wcMatch = [
+                ...TAC.Globals.tagword.matchAll(
+                    new RegExp(
+                        WC_REGEX.source.replaceAll("__", TAC.Utils.escapeRegExp(TAC.CFG.wcWrap)),
+                        "g"
+                    )
+                ),
+            ];
+            let wcFile = wcMatch[0][1];
+            let wcWord = wcMatch[0][2];

-        // Look in normal wildcard files
-        let wcFound = wildcardFiles.find(x => x[1].toLowerCase() === wcFile);
-        // Use found wildcard file or look in external wildcard files
-        let wcPair = wcFound || wildcardExtFiles.find(x => x[1].toLowerCase() === wcFile);
+            // Look in normal wildcard files
+            let wcFound = TAC.Globals.wildcardFiles.filter((x) => x[1].toLowerCase() === wcFile);
+            if (wcFound.length === 0) wcFound = null;
+            // Use found wildcard file or look in external wildcard files
+            let wcPairs =
+                wcFound ||
+                TAC.Globals.wildcardExtFiles.filter((x) => x[1].toLowerCase() === wcFile);

-        let wildcards = (await readFile(`${wcPair[0]}/${wcPair[1]}.txt`)).split("\n")
-            .filter(x => x.trim().length > 0 && !x.startsWith('#'));  // Remove empty lines and comments
+            if (!wcPairs) return [];

-        let finalResults = [];
-        let tempResults = wildcards.filter(x => (wcWord !== null && wcWord.length > 0) ? x.toLowerCase().includes(wcWord) : x) // Filter by tagword
-        tempResults.forEach(t => {
-            let result = new AutocompleteResult(t.trim(), ResultType.wildcardTag);
-            result.meta = wcFile;
-            finalResults.push(result);
-        });
+            let wildcards = [];
+            for (let i = 0; i < wcPairs.length; i++) {
+                const basePath = wcPairs[i][0];
+                const fileName = wcPairs[i][1];
+                if (!basePath || !fileName) return;

-        return finalResults;
-    }
-}
-
-class WildcardFileParser extends BaseTagParser {
-    parse() {
-        // Show available wildcard files
-        let tempResults = [];
-        if (tagword !== "__") {
-            let lmb = (x) => x[1].toLowerCase().includes(tagword.replace("__", ""))
-            tempResults = wildcardFiles.filter(lmb).concat(wildcardExtFiles.filter(lmb)) // Filter by tagword
-        } else {
-            tempResults = wildcardFiles.concat(wildcardExtFiles);
-        }
-
-        let finalResults = [];
-        // Get final results
-        tempResults.forEach(wcFile => {
-            let result = new AutocompleteResult(wcFile[1].trim(), ResultType.wildcardFile);
-            result.meta = "Wildcard file";
-            finalResults.push(result);
-        });
-
-        return finalResults;
-    }
-}
-
-async function load() {
-    if (wildcardFiles.length === 0 && wildcardExtFiles.length === 0) {
-        try {
-            let wcFileArr = (await readFile(`${tagBasePath}/temp/wc.txt`)).split("\n");
-            let wcBasePath = wcFileArr[0].trim(); // First line should be the base path
-            wildcardFiles = wcFileArr.slice(1)
-                .filter(x => x.trim().length > 0) // Remove empty lines
-                .map(x => [wcBasePath, x.trim().replace(".txt", "")]); // Remove file extension & newlines
-
-            // To support multiple sources, we need to separate them using the provided "-----" strings
-            let wcExtFileArr = (await readFile(`${tagBasePath}/temp/wce.txt`)).split("\n");
-            let splitIndices = [];
-            for (let index = 0; index < wcExtFileArr.length; index++) {
-                if (wcExtFileArr[index].trim() === "-----") {
-                    splitIndices.push(index);
+                // YAML wildcards are already loaded as json, so we can get the values directly.
+                // basePath is the name of the file in this case, and fileName the key
+                if (basePath.endsWith(".yaml")) {
+                    const getDescendantProp = (obj, desc) => {
+                        const arr = desc.split("/");
+                        while (arr.length) {
+                            obj = obj[arr.shift()];
+                        }
+                        return obj;
+                    };
+                    wildcards = wildcards.concat(
+                        getDescendantProp(TAC.Globals.yamlWildcards[basePath], fileName)
+                    );
+                } else {
+                    const fileContent = (
+                        await TAC.Utils.fetchAPI(
+                            `tacapi/v1/wildcard-contents?basepath=${basePath}&filename=${fileName}.txt`,
+                            false
+                        )
+                    )
+                        .split("\n")
+                        .filter((x) => x.trim().length > 0 && !x.startsWith("#")); // Remove empty lines and comments
+                    wildcards = wildcards.concat(fileContent);
                }
            }
-            // For each group, add them to the wildcardFiles array with the base path as the first element
-            for (let i = 0; i < splitIndices.length; i++) {
-                let start = splitIndices[i - 1] || 0;
-                if (i > 0) start++; // Skip the "-----" line
-                let end = splitIndices[i];

-                let wcExtFile = wcExtFileArr.slice(start, end);
-                let base = wcExtFile[0].trim() + "/";
-                wcExtFile = wcExtFile.slice(1)
-                    .filter(x => x.trim().length > 0) // Remove empty lines
-                    .map(x => x.trim().replace(base, "").replace(".txt", "")); // Remove file extension & newlines;
+            if (TAC.CFG.sortWildcardResults) wildcards.sort((a, b) => a.localeCompare(b));

-                wcExtFile = wcExtFile.map(x => [base, x]);
-                wildcardExtFiles.push(...wcExtFile);
-            }
-        } catch (e) {
-            console.error("Error loading wildcards: " + e);
+            let finalResults = [];
+            let tempResults = wildcards.filter((x) =>
+                wcWord !== null && wcWord.length > 0 ? x.toLowerCase().includes(wcWord) : x
+            ); // Filter by tagword
+            tempResults.forEach((t) => {
+                let result = new TAC.AutocompleteResult(t.trim(), TAC.ResultType.wildcardTag);
+                result.meta = wcFile;
+                finalResults.push(result);
+            });
+
+            return finalResults;
        }
    }
-}

-function sanitize(tagType, text) {
-    if (tagType === ResultType.wildcardFile) {
-        return `__${text}__`;
-    } else if (tagType === ResultType.wildcardTag) {
-        return text.replace(/^.*?: /g, "");
+    class WildcardFileParser extends TAC.BaseTagParser {
+        parse() {
+            // Show available wildcard files
+            let tempResults = [];
+            if (TAC.Globals.tagword !== TAC.CFG.wcWrap) {
+                let lmb = (x) =>
+                    x[1].toLowerCase().includes(TAC.Globals.tagword.replace(TAC.CFG.wcWrap, ""));
+                tempResults = TAC.Globals.wildcardFiles
+                    .filter(lmb)
+                    .concat(TAC.Globals.wildcardExtFiles.filter(lmb)); // Filter by tagword
+            } else {
+                tempResults = TAC.Globals.wildcardFiles.concat(TAC.Globals.wildcardExtFiles);
+            }
+
+            let finalResults = [];
+            const alreadyAdded = new Map();
+            // Get final results
+            tempResults.forEach((wcFile) => {
+                // Skip duplicate entries incase multiple files have the same name or yaml category
+                if (alreadyAdded.has(wcFile[1])) return;
+
+                let result = null;
+                if (wcFile[0].endsWith(".yaml")) {
+                    result = new TAC.AutocompleteResult(
+                        wcFile[1].trim(),
+                        TAC.ResultType.yamlWildcard
+                    );
+                    result.meta = "YAML wildcard collection";
+                } else {
+                    result = new TAC.AutocompleteResult(
+                        wcFile[1].trim(),
+                        TAC.ResultType.wildcardFile
+                    );
+                    result.meta = "Wildcard file";
+                    result.sortKey = wcFile[2].trim();
+                }
+
+                finalResults.push(result);
+                alreadyAdded.set(wcFile[1], true);
+            });
+
+            finalResults.sort(TAC.Utils.getSortFunction());
+
+            return finalResults;
+        }
    }
-    return null;
-}

-function keepOpenIfWildcard(tagType, sanitizedText, newPrompt, textArea) {
-    // If it's a wildcard, we want to keep the results open so the user can select another wildcard
-    if (tagType === ResultType.wildcardFile) {
-        hideBlocked = true;
-        autocomplete(textArea, newPrompt, sanitizedText);
-        setTimeout(() => { hideBlocked = false; }, 450);
-        return true;
+    async function load() {
+        if (TAC.Globals.wildcardFiles.length === 0 && TAC.Globals.wildcardExtFiles.length === 0) {
+            try {
+                let wcFileArr = await TAC.Utils.loadCSV(`${TAC.Globals.tagBasePath}/temp/wc.txt`);
+                if (wcFileArr && wcFileArr.length > 0) {
+                    let wcBasePath = wcFileArr[0][0].trim(); // First line should be the base path
+                    TAC.Globals.wildcardFiles = wcFileArr
+                        .slice(1)
+                        .filter((x) => x[0]?.trim().length > 0) //Remove empty lines
+                        .map((x) => [wcBasePath, x[0]?.trim().replace(".txt", ""), x[1]]); // Remove file extension & newlines
+                }
+
+                // To support multiple sources, we need to separate them using the provided "-----" strings
+                let wcExtFileArr = await TAC.Utils.loadCSV(
+                    `${TAC.Globals.tagBasePath}/temp/wce.txt`
+                );
+                let splitIndices = [];
+                for (let index = 0; index < wcExtFileArr.length; index++) {
+                    if (wcExtFileArr[index][0].trim() === "-----") {
+                        splitIndices.push(index);
+                    }
+                }
+                // For each group, add them to the wildcardFiles array with the base path as the first element
+                for (let i = 0; i < splitIndices.length; i++) {
+                    let start = splitIndices[i - 1] || 0;
+                    if (i > 0) start++; // Skip the "-----" line
+                    let end = splitIndices[i];
+
+                    let wcExtFile = wcExtFileArr.slice(start, end);
+                    if (wcExtFile && wcExtFile.length > 0) {
+                        let base = wcExtFile[0][0].trim() + "/";
+                        wcExtFile = wcExtFile
+                            .slice(1)
+                            .filter((x) => x[0]?.trim().length > 0) //Remove empty lines
+                            .map((x) => [
+                                base,
+                                x[0]?.trim().replace(base, "").replace(".txt", ""),
+                                x[1],
+                            ]);
+                        TAC.Globals.wildcardExtFiles.push(...wcExtFile);
+                    }
+                }
+
+                // Load the yaml wildcard json file and append it as a wildcard file, appending each key as a path component until we reach the end
+                TAC.Globals.yamlWildcards = await TAC.Utils.readFile(
+                    `${TAC.Globals.tagBasePath}/temp/wc_yaml.json`,
+                    true
+                );
+
+                // Append each key as a path component until we reach a leaf
+                Object.keys(TAC.Globals.yamlWildcards).forEach((file) => {
+                    const flattened = TAC.Utils.flatten(TAC.Globals.yamlWildcards[file], [], "/");
+                    Object.keys(flattened).forEach((key) => {
+                        TAC.Globals.wildcardExtFiles.push([file, key]);
+                    });
+                });
+            } catch (e) {
+                console.error("Error loading wildcards: " + e);
+            }
+        }
    }
-    return false;
-}

-// Register the parsers
-PARSERS.push(new WildcardParser(WC_TRIGGER));
-PARSERS.push(new WildcardFileParser(WC_FILE_TRIGGER));
+    function sanitize(tagType, text) {
+        if (tagType === TAC.ResultType.wildcardFile || tagType === TAC.ResultType.yamlWildcard) {
+            return `${TAC.CFG.wcWrap}${text}${TAC.CFG.wcWrap}`;
+        } else if (tagType === TAC.ResultType.wildcardTag) {
+            return text;
+        }
+        return null;
+    }

-// Add our utility functions to their respective queues
-QUEUE_FILE_LOAD.push(load);
-QUEUE_SANITIZE.push(sanitize);
-QUEUE_AFTER_INSERT.push(keepOpenIfWildcard);
+    function keepOpenIfWildcard(tagType, sanitizedText, newPrompt, textArea) {
+        // If it's a wildcard, we want to keep the results open so the user can select another wildcard
+        if (tagType === TAC.ResultType.wildcardFile || tagType === TAC.ResultType.yamlWildcard) {
+            TAC.Globals.hideBlocked = true;
+            setTimeout(() => {
+                TAC.Globals.hideBlocked = false;
+            }, 450);
+            return true;
+        }
+        return false;
+    }
+
+    // Register the parsers
+    TAC.Ext.PARSERS.push(new WildcardParser(WC_TRIGGER));
+    TAC.Ext.PARSERS.push(new WildcardFileParser(WC_FILE_TRIGGER));
+
+    // Add our utility functions to their respective queues
+    TAC.Ext.QUEUE_FILE_LOAD.push(load);
+    TAC.Ext.QUEUE_SANITIZE.push(sanitize);
+    TAC.Ext.QUEUE_AFTER_INSERT.push(keepOpenIfWildcard);
+})();
--- a/javascript/tagAutocomplete.js
+++ b/javascript/tagAutocomplete.js
--- a/scripts/model_keyword_support.py
+++ b/scripts/model_keyword_support.py
@@ -0,0 +1,85 @@
+# This file provides support for the model-keyword extension to add known lora keywords on completion
+
+import csv
+import hashlib
+from pathlib import Path
+
+from scripts.shared_paths import EXT_PATH, STATIC_TEMP_PATH, TEMP_PATH
+
+# Set up our hash cache
+known_hashes_file = TEMP_PATH.joinpath("known_lora_hashes.txt")
+known_hashes_file.touch()
+file_needs_update = False
+
+# Load the hashes from the file
+hash_dict = {}
+
+
+def load_hash_cache():
+    if not known_hashes_file.exists():
+        known_hashes_file.touch()
+    with open(known_hashes_file, "r", encoding="utf-8") as file:
+        reader = csv.reader(
+            file.readlines(), delimiter=",", quotechar='"', skipinitialspace=True
+        )
+        for line in reader:
+            name, hash, mtime = line
+            hash_dict[name] = (hash, mtime)
+
+
+def update_hash_cache():
+    global file_needs_update
+    if file_needs_update:
+        if not known_hashes_file.exists():
+            known_hashes_file.touch()
+        with open(known_hashes_file, "w", encoding="utf-8", newline='') as file:
+            writer = csv.writer(file)
+            for name, (hash, mtime) in hash_dict.items():
+                writer.writerow([name, hash, mtime])
+
+
+# Copy of the fast inaccurate hash function from the extension
+# with some modifications to load from and write to the cache
+def get_lora_simple_hash(path):
+    global file_needs_update
+    mtime = str(Path(path).stat().st_mtime)
+    filename = Path(path).name
+
+    if filename in hash_dict:
+        (hash, old_mtime) = hash_dict[filename]
+        if mtime == old_mtime:
+            return hash
+    try:
+        with open(path, "rb") as file:
+            m = hashlib.sha256()
+
+            file.seek(0x100000)
+            m.update(file.read(0x10000))
+            hash = m.hexdigest()[0:8]
+
+            hash_dict[filename] = (hash, mtime)
+            file_needs_update = True
+
+            return hash
+    except FileNotFoundError:
+        return "NOFILE"
+
+
+# Find the path of the original model-keyword extension
+def write_model_keyword_path():
+    # Ensure the file exists even if the extension is not installed
+    mk_path = STATIC_TEMP_PATH.joinpath("modelKeywordPath.txt")
+    mk_path.write_text("")
+
+    base_keywords = list(EXT_PATH.glob("*/lora-keyword.txt"))
+    custom_keywords = list(EXT_PATH.glob("*/lora-keyword-user.txt"))
+    custom_found = custom_keywords is not None and len(custom_keywords) > 0
+    if base_keywords is not None and len(base_keywords) > 0:
+        with open(mk_path, "w", encoding="utf-8") as f:
+            f.write(f"{base_keywords[0].parent.as_posix()},{custom_found}")
+        return True
+    else:
+        print(
+            "Tag Autocomplete: Could not locate model-keyword extension, Lora trigger word completion will be limited to those added through the extra networks menu."
+        )
+        return False
--- a/scripts/shared_paths.py
+++ b/scripts/shared_paths.py
@@ -0,0 +1,92 @@
+from pathlib import Path
+
+from modules import scripts, shared
+
+try:
+    from modules.paths import extensions_dir, script_path
+
+    # Webui root path
+    FILE_DIR = Path(script_path).absolute()
+
+    # The extension base path
+    EXT_PATH = Path(extensions_dir).absolute()
+except ImportError:
+    # Webui root path
+    FILE_DIR = Path().absolute()
+    # The extension base path
+    EXT_PATH = FILE_DIR.joinpath("extensions").absolute()
+
+# Tags base path
+TAGS_PATH = Path(scripts.basedir()).joinpath("tags").absolute()
+
+# The path to the folder containing the wildcards and embeddings
+try: # SD.Next
+    WILDCARD_PATH = Path(shared.opts.wildcards_dir).absolute()
+except Exception: # A1111
+    WILDCARD_PATH = FILE_DIR.joinpath("scripts/wildcards").absolute()
+EMB_PATH = Path(shared.cmd_opts.embeddings_dir).absolute()
+
+# Forge Classic detection
+try:
+    from modules_forge.forge_version import version as forge_version
+    IS_FORGE_CLASSIC = forge_version == "classic"
+except ImportError:
+    IS_FORGE_CLASSIC = False
+
+# Forge Classic skips it
+if not IS_FORGE_CLASSIC:
+    try:
+        HYP_PATH = Path(shared.cmd_opts.hypernetwork_dir).absolute()
+    except AttributeError:
+        HYP_PATH = None
+else:
+    HYP_PATH = None
+
+try:
+    LORA_PATH = Path(shared.cmd_opts.lora_dir).absolute()
+except AttributeError:
+    LORA_PATH = None
+
+try:
+    try:
+        LYCO_PATH = Path(shared.cmd_opts.lyco_dir_backcompat).absolute()
+    except:
+        LYCO_PATH = Path(shared.cmd_opts.lyco_dir).absolute() # attempt original non-backcompat path
+except AttributeError:
+    LYCO_PATH = None
+
+
+def find_ext_wildcard_paths():
+    """Returns the path to the extension wildcards folder"""
+    found = list(EXT_PATH.glob("*/wildcards/"))
+    # Try to find the wildcard path from the shared opts
+    try:
+        from modules.shared import opts
+    except ImportError:  # likely not in an a1111 context
+        opts = None
+
+    # Append custom wildcard paths
+    custom_paths = [
+        getattr(shared.cmd_opts, "wildcards_dir", None),    # Cmd arg from the wildcard extension
+        getattr(opts, "wildcard_dir", None),                # Custom path from sd-dynamic-prompts
+    ]
+    for path in [Path(p).absolute() for p in custom_paths if p is not None]:
+        if path.exists():
+            found.append(path)
+
+    return found
+
+
+# The path to the extension wildcards folder
+WILDCARD_EXT_PATHS = find_ext_wildcard_paths()
+
+# The path to the temporary files
+# In the webui root, on windows it exists by default, on linux it doesn't
+STATIC_TEMP_PATH = FILE_DIR.joinpath("tmp").absolute()
+TEMP_PATH = TAGS_PATH.joinpath("temp").absolute()  # Extension specific temp files
+
+# Make sure these folders exist
+if not TEMP_PATH.exists():
+    TEMP_PATH.mkdir()
+if not STATIC_TEMP_PATH.exists():
+    STATIC_TEMP_PATH.mkdir()
--- a/scripts/tag_autocomplete_helper.py
+++ b/scripts/tag_autocomplete_helper.py
--- a/scripts/tag_frequency_db.py
+++ b/scripts/tag_frequency_db.py
@@ -0,0 +1,190 @@
+import sqlite3
+from contextlib import contextmanager
+
+from scripts.shared_paths import TAGS_PATH
+
+db_file = TAGS_PATH.joinpath("tag_frequency.db")
+timeout = 30
+db_ver = 1
+
+
+@contextmanager
+def transaction(db=db_file):
+    """Context manager for database transactions.
+    Ensures that the connection is properly closed after the transaction.
+    """
+    try:
+        conn = sqlite3.connect(db, timeout=timeout)
+        
+        conn.isolation_level = None
+        cursor = conn.cursor()
+        cursor.execute("BEGIN")
+        yield cursor
+        cursor.execute("COMMIT")
+    except sqlite3.Error as e:
+        print("Tag Autocomplete: Frequency database error:", e)
+    finally:
+        if conn:
+            conn.close()
+
+
+class TagFrequencyDb:
+    """Class containing creation and interaction methods for the tag frequency database"""
+
+    def __init__(self) -> None:
+        self.version = self.__check()
+
+    def __check(self):
+        if not db_file.exists():
+            print("Tag Autocomplete: Creating frequency database")
+            with transaction() as cursor:
+                self.__create_db(cursor)
+                self.__update_db_data(cursor, "version", db_ver)
+            print("Tag Autocomplete: Database successfully created")
+
+        return self.__get_version()
+
+    def __create_db(self, cursor: sqlite3.Cursor):
+        cursor.execute(
+            """
+        CREATE TABLE IF NOT EXISTS db_data (
+            key TEXT PRIMARY KEY,
+            value TEXT
+        )
+        """
+        )
+
+        cursor.execute(
+            """
+        CREATE TABLE IF NOT EXISTS tag_frequency (
+            name TEXT NOT NULL,
+            type INT NOT NULL,
+            count_pos INT,
+            count_neg INT,
+            last_used TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            PRIMARY KEY (name, type)
+        )
+        """
+        )
+
+    def __update_db_data(self, cursor: sqlite3.Cursor, key, value):
+        cursor.execute(
+            """
+        INSERT OR REPLACE
+        INTO db_data (key, value)
+        VALUES (?, ?)
+        """,
+            (key, value),
+        )
+
+    def __get_version(self):
+        db_version = None
+        with transaction() as cursor:
+            cursor.execute(
+                """
+            SELECT value
+            FROM db_data
+            WHERE key = 'version'
+            """
+            )
+            db_version = cursor.fetchone()
+
+        return db_version[0] if db_version else 0
+
+    def get_all_tags(self):
+        with transaction() as cursor:
+            cursor.execute(
+                f"""
+            SELECT name, type, count_pos, count_neg, last_used
+            FROM tag_frequency
+            WHERE count_pos > 0 OR count_neg > 0
+            ORDER BY count_pos + count_neg DESC
+            """
+            )
+            tags = cursor.fetchall()
+
+        return tags
+
+    def get_tag_count(self, tag, ttype, negative=False):
+        count_str = "count_neg" if negative else "count_pos"
+        with transaction() as cursor:
+            cursor.execute(
+                f"""
+            SELECT {count_str}, last_used
+            FROM tag_frequency
+            WHERE name = ? AND type = ?
+            """,
+                (tag, ttype),
+            )
+            tag_count = cursor.fetchone()
+
+        if tag_count:
+            return tag_count[0], tag_count[1]
+        else:
+            return 0, None
+
+    def get_tag_counts(self, tags: list[str], ttypes: list[str], negative=False, date_limit=None):
+        count_str = "count_neg" if negative else "count_pos"
+        with transaction() as cursor:
+            for tag, ttype in zip(tags, ttypes):
+                if date_limit is not None:
+                    cursor.execute(
+                        f"""
+                    SELECT {count_str}, last_used
+                    FROM tag_frequency
+                    WHERE name = ? AND type = ?
+                    AND last_used > datetime('now', '-' || ? || ' days')
+                    """,
+                        (tag, ttype, date_limit),
+                    )
+                else:
+                    cursor.execute(
+                        f"""
+                    SELECT {count_str}, last_used
+                    FROM tag_frequency
+                    WHERE name = ? AND type = ?
+                    """,
+                        (tag, ttype),
+                    )
+                tag_count = cursor.fetchone()
+                if tag_count:
+                    yield (tag, ttype, tag_count[0], tag_count[1]) 
+                else:
+                    yield (tag, ttype, 0, None)
+
+    def increase_tag_count(self, tag, ttype, negative=False):
+        pos_count = self.get_tag_count(tag, ttype, False)[0]
+        neg_count = self.get_tag_count(tag, ttype, True)[0]
+
+        if negative:
+            neg_count += 1
+        else:
+            pos_count += 1
+
+        with transaction() as cursor:
+            cursor.execute(
+                f"""
+            INSERT OR REPLACE
+            INTO tag_frequency (name, type, count_pos, count_neg)
+            VALUES (?, ?, ?, ?)
+            """,
+                (tag, ttype, pos_count, neg_count),
+            )
+
+    def reset_tag_count(self, tag, ttype, positive=True, negative=False):
+        if positive and negative:
+            set_str = "count_pos = 0, count_neg = 0"
+        elif positive:
+            set_str = "count_pos = 0"
+        elif negative:
+            set_str = "count_neg = 0"
+
+        with transaction() as cursor:
+            cursor.execute(
+                f"""
+            UPDATE tag_frequency
+            SET {set_str}
+            WHERE name = ? AND type = ?
+            """,
+                (tag, ttype),
+            )
--- a/tags/EnglishDictionary.csv
+++ b/tags/EnglishDictionary.csv
--- a/tags/danbooru.csv
+++ b/tags/danbooru.csv
--- a/tags/danbooru_e621_merged.csv
+++ b/tags/danbooru_e621_merged.csv
--- a/tags/demo-chants.json
+++ b/tags/demo-chants.json
@@ -28,5 +28,17 @@
        "terms": "Water, Magic, Fancy",
        "content": "(extremely detailed CG unity 8k wallpaper), (masterpiece), (best quality), (ultra-detailed), (best illustration),(best shadow), (an extremely delicate and beautiful), classic, dynamic angle, floating, fine detail, Depth of field, classic, (painting), (sketch), (bloom), (shine), glinting stars,\n\na girl, solo, bare shoulders, flat chest, diamond and glaring eyes, beautiful detailed cold face, very long blue and sliver hair, floating black feathers, wavy hair, extremely delicate and beautiful girls, beautiful detailed eyes, glowing eyes,\n\nriver, (forest),palace, (fairyland,feather,flowers, nature),(sunlight),Hazy fog, mist",
        "color": 5
+    },
+    {
+        "name": "Pony-Positive",
+        "terms": "Pony,Score,Positive,Quality",
+        "content": "score_9, score_8_up, score_7_up, score_6_up, source_anime, source_furry, source_pony, source_cartoon",
+        "color": 1
+    },
+    {
+        "name": "Pony-Negative",
+        "terms": "Pony,Score,Negative,Quality",
+        "content": "score_1, score_2, score_3, score_4, score_5, source_anime, source_furry, source_pony, source_cartoon",
+        "color": 3
    }
 ]
--- a/tags/derpibooru.csv
+++ b/tags/derpibooru.csv
--- a/tags/e621.csv
+++ b/tags/e621.csv
--- a/tags/e621_sfw.csv
+++ b/tags/e621_sfw.csv
--- a/tags/noob_characters-chants.json
+++ b/tags/noob_characters-chants.json