Upload 21 files

a1111-sd-webui-tagcomplete/.gitignore

@@ -0,0 +1,2 @@
+tags/temp/
+__pycache__/

a1111-sd-webui-tagcomplete/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Dominik Reh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

a1111-sd-webui-tagcomplete/README.md

@@ -0,0 +1,177 @@
+![tag_autocomplete_light](https://user-images.githubusercontent.com/34448969/208306863-90bbd663-2cb4-47f1-a7fe-7b662a7b95e2.png)
+
+# Booru tag autocompletion for A1111
+
+[![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)
+
+## [中文文档](./README_ZH.md)
+
+This custom script serves as a drop-in extension for the popular [AUTOMATIC1111 web UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) for Stable Diffusion.
+
+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), using exact tags in prompts can often improve composition and help to achieve a wanted look.
+
+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).
+
+## Common Problems & Known Issues:
+- Depending on your browser settings, sometimes an old version of the script can get cached. Try `CTRL+F5` to force-reload the site without cache if e.g. a new feature doesn't appear for you after an update.
+- If `replaceUnderscores` is active, the script will currently only partially replace edited tags containing multiple words in brackets.
+For example, editing `atago (azur lane)`, it would be replaced with e.g. `taihou (azur lane), lane)`, since the script currently doesn't see the second part of the bracket as the same tag. So in those cases you should delete the old tag beforehand.
+
+## Screenshots
+Demo video (with keyboard navigation):
+
+https://user-images.githubusercontent.com/34448969/200128020-10d9a8b2-cea6-4e3f-bcd2-8c40c8c73233.mp4
+
+Wildcard script support:
+
+https://user-images.githubusercontent.com/34448969/200128031-22dd7c33-71d1-464f-ae36-5f6c8fd49df0.mp4
+
+Dark and Light mode supported, including tag colors:
+
+![results_dark](https://user-images.githubusercontent.com/34448969/200128214-3b6f21b4-9dda-4acf-820e-5df0285c30d6.png)
+![results_light](https://user-images.githubusercontent.com/34448969/200128217-bfac8b60-6673-447b-90fd-dc6326f1618c.png)
+
+## Installation
+### As an extension (recommended)
+Either clone the repo into your extensions folder:
+```bash
+git clone "https://github.com/DominikDoom/a1111-sd-webui-tagcomplete.git" extensions/tag-autocomplete
+```
+(The second argument specifies the name of the folder, you can choose whatever you like).
+
+Or create a folder there manually and place the `javascript`, `scripts` and `tags` folders in it.
+
+### In the root folder (legacy)
+This installation method is for old webui versions pre-extension system, it will not work on current versions!
+
+---
+
+In both configurations, the `tags` folder contains `colors.json` and the tag data the script uses for autocompletion. By default, Danbooru and e621 tags are included.
+After scanning for embeddings and wildcards, the script will also create a `temp` directory here which lists the found files so they can be accessed in the browser side of the script. You can delete the temp folder without consequences as it will be recreated on the next startup.
+
+### Important:
+The script needs **all three folders** to work properly.
+
+## Wildcard & Embedding support
+Autocompletion also works with wildcard files used by [this script](https://github.com/jtkelm2/stable-diffusion-webui-1/blob/master/scripts/wildcards.py) of the same name or other similar scripts/extensions. This enables you to either insert categories to be replaced by the script, or even replace them with the actual wildcard file content in the same step. Wildcards are searched for in every extension folder as well as the `scripts/wildcards` folder to support legacy versions. This means that you can combine wildcards from multiple extensions. Nested folders are also supported if you have grouped your wildcards in that way.
+
+It also scans the embeddings folder and displays completion hints for the names of all .pt, .bin and .png files inside if you start typing `<`. Note that some normal tags also use < in Kaomoji (like ">_<" for example), so the results will contain both.
+
+## Settings
+
+The extension has a large amount of configuration & customizability built in:
+
+![image](https://user-images.githubusercontent.com/34448969/204093162-99c6a0e7-8183-4f47-963b-1f172774f527.png)
+
+| Setting	| Description |
+|---------|-------------|
+| tagFile | Specifies the tag file to use. You can provide a custom tag database of your liking, but since the script was developed with Danbooru tags in mind, it might not work properly with other configurations.|
+| activeIn | Allows to selectively (de)activate the script for txt2img, img2img, and the negative prompts for both. |
+| maxResults | How many results to show max. For the default tag set, the results are ordered by occurence count. For embeddings and wildcards it will show all results in a scrollable list. |
+| resultStepLength | Allows to load results in smaller batches of the specified size for better performance in long lists or if showAllResults is true. |
+| delayTime | Specifies how much to wait in milliseconds before triggering autocomplete. Helps prevent too frequent updates while typing. |
+| showAllResults | If true, will ignore maxResults and show all results in a scrollable list. **Warning:** can lag your browser for long lists. |
+| replaceUnderscores | If true, undescores are replaced with spaces on clicking a tag. Might work better for some models. |
+| escapeParentheses | If true, escapes tags containing () so they don't contribute to the web UI's prompt weighting functionality. |
+| appendComma | Specifies the starting value of the "Append commas" UI switch. If UI options are disabled, this will always be used. |
+| useWildcards | Used to toggle the wildcard completion functionality. |
+| useEmbeddings | Used to toggle the embedding completion functionality. |
+| alias | Options for aliases. More info in the section below. |
+| translation | Options for translations. More info in the section below.  |
+| extras | Options for additional tag files / aliases / translations. More info in the section below. |
+
+### colors.json
+Additionally, tag type colors can be specified using the separate `colors.json` file in the extension's `tags` folder.
+You can also add new ones here for custom tag files (same name as filename, without the .csv). The first value is for dark, the second for light mode. Color names and hex codes should both work.
+```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"]
+	}
+}
+```
+The numbers are specifying the tag type, which is dependent on the tag source. For an example, see [CSV tag data](#csv-tag-data).
+
+### Aliases, Translations & Extra tags
+#### Aliases
+Like on Booru sites, tags can have one or multiple aliases which redirect to the actual value on completion. These will be searchable / shown according to the settings in `config.json`:
+- `searchByAlias` - Whether to also search for the alias or only the actual tag.
+- `onlyShowAlias` - Shows only the alias instead of `alias -> actual`. Only for displaying, the inserted text at the end is still the actual tag.
+
+#### 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 `oldFormat` to use that instead.
+
+Example with chinese translation:
+
+![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
+An extra file can be used to add new / custom tags not included in the main set.
+The format is identical to the normal tag format shown in [CSV tag data](#csv-tag-data) below, with one exception:
+Since custom tags likely have no count, column three (or two if counting from zero) is instead used for the gray meta text displayed next to the tag.
+If left empty, it will instead show "Custom tag".
+
+An example with the included (very basic) extra-quality-tags.csv file:
+
+![image](https://user-images.githubusercontent.com/34448969/218264276-cd77ba8e-62d8-41a2-b03c-6c04887ee18b.png)
+
+Whether the custom tags should be added before or after the normal tags can be chosen in the settings.
+
+## CSV tag data
+The script expects a CSV file with tags saved in the following way:
+```csv
+<name>,<type>,<postCount>,"<aliases>"
+```
+Example:
+```csv
+1girl,0,4114588,"1girls,sole_female"
+solo,0,3426446,"female_solo,solo_female"
+highres,5,3008413,"high_res,high_resolution,hires"
+long_hair,0,2898315,longhair
+commentary_request,5,2610959,
+```
+Notably, it does not expect column names in the first row and both count and aliases are technically optional,
+although count is always included in the default data. Multiple aliases need to be comma separated as well, but encased in string quotes to not break the CSV parsing.
+
+The numbering system follows the [tag API docs](https://danbooru.donmai.us/wiki_pages/api%3Atags) of Danbooru:
+| Value	| Description |
+|-------|-------------|
+|0	| General     |
+|1	| Artist      |
+|3	| Copyright   |
+|4	| Character   |
+|5	| Meta        |
+
+or similarly for e621:
+| Value	| Description |
+|-------|-------------|
+|-1	| Invalid     |
+|0	| General     |
+|1	| Artist      |
+|3	| Copyright   |
+|4	| Character   |
+|5	| Species     |
+|6	| Invalid     |
+|7	| Meta        |
+|8	| Lore        |
+
+The tag type is used for coloring entries in the result list.

a1111-sd-webui-tagcomplete/README_ZH.md

@@ -0,0 +1,172 @@
+![tag_autocomplete_light_zh](https://user-images.githubusercontent.com/34448969/208307331-430696b4-e854-4458-b9e9-f6a6594f19e1.png)
+
+# Booru tag autocompletion for A1111
+
+[![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)
+## [English Document](./README.md)
+
+## 功能概述
+
+本脚本为 [AUTOMATIC1111 web UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui)的自定义脚本,能在输入Tag时提供booru风格（如Danbooru）的TAG自动补全。因为有一些模型是基于这种TAG风格训练的（例如[Waifu Diffusion](https://github.com/harubaru/waifu-diffusion)），因此使用这些Tag能获得较为精确的效果。
+
+这个脚本的创建是为了减少因复制Tag在Web UI和 booru网站的反复切换。
+你可以按照[以下方法](#installation)下载或拷贝文件，也可以使用[Releases](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/releases)中打包好的文件。
+
+## 常见问题 & 已知缺陷:
+- 当`replaceUnderscores`选项开启时, 脚本只会替换Tag的一部分如果Tag包含多个单词,比如将`atago (azur lane)`修改`atago`为`taihou`并使用自动补全时.会得到 `taihou (azur lane), lane)`的结果, 因为脚本没有把后面的部分认为成同一个Tag。
+
+## 演示与截图
+演示视频(使用了键盘导航):
+
+https://user-images.githubusercontent.com/34448969/200128020-10d9a8b2-cea6-4e3f-bcd2-8c40c8c73233.mp4
+
+Wildcard支持演示:
+
+https://user-images.githubusercontent.com/34448969/200128031-22dd7c33-71d1-464f-ae36-5f6c8fd49df0.mp4
+
+深浅色主题支持,包括Tag的颜色:
+
+![results_dark](https://user-images.githubusercontent.com/34448969/200128214-3b6f21b4-9dda-4acf-820e-5df0285c30d6.png)
+![results_light](https://user-images.githubusercontent.com/34448969/200128217-bfac8b60-6673-447b-90fd-dc6326f1618c.png)
+
+## 安装
+### 作为一种扩展（推荐）
+要么把它克隆到你的扩展文件夹里
+```bash
+git clone "https://github.com/DominikDoom/a1111-sd-webui-tagcomplete.git" extensions/tag-autocomplete
+```
+(第二个参数指定文件夹的名称，你可以选择任何你喜欢的东西）。
+
+或者手动创建一个文件夹，将 `javascript`、`scripts`和`tags`文件夹放在其中。
+
+### 在根目录下（过时的方法）
+这种安装方法适用于添加扩展系统之前的旧版webui，在目前的版本上是行不通的。
+
+---
+在这两种配置中，标签文件夹包含`colors.json`和脚本用于自动完成的标签数据。
+默认情况下，Tag数据包括`Danbooru.csv`和`e621.csv`。
+
+在扫描过`/embeddings`和wildcards后，会将列表存放在`tags/temp`文件夹下。删除该文件夹不会有任何影响，下次启动时它会重新创建。
+
+### 注意:
+本脚本的允许需要**全部的三个文件夹**。
+
+## [Wildcard](https://github.com/jtkelm2/stable-diffusion-webui-1/blob/master/scripts/wildcards.py) &  Embedding 支持
+自动补全同样适用于 [Wildcard](https://github.com/jtkelm2/stable-diffusion-webui-1/blob/master/scripts/wildcards.py)中所述的通配符文件(后面有演示视频)。这将使你能够插入Wildcard脚本需要的通配符，更进一步的，你还可以插入通配符文件内的某个具体Tag。
+
+当输入`__`字符时，`/scripts/wildcards`文件夹下的通配符文件会列出到自动补全，当你选择某个具体通配符文件时,会列出其中的所有的具体Tag,但如果你仅需要选择某个通配符，请按下空格。
+
+当输入`<`字符时，`embeddings`文件夹下的`.pt`和`.bin`文件会列出到自动完成。需要注意的是，一些颜文字也会包含`<`(比如`>_<`),所以它们也会出现在结果中。
+
+现在这项功能默认是启用的，并会自动扫描`/embeddings`和`/scripts/wildcards`文件夹，不再需要使用`tags/wildcardNames.txt`文件了，早期版本的用户可以将它删除。
+
+## 配置文件
+该扩展有大量的配置和可定制性的内建：
+
+![image](https://user-images.githubusercontent.com/34448969/204093162-99c6a0e7-8183-4f47-963b-1f172774f527.png)
+
+| 设置	| 描述 |
+|---------|-------------|
+| tagFile | 指定要使用的标记文件。您可以提供您喜欢的自定义标签数据库，但由于该脚本是在考虑 Danbooru 标签的情况下开发的，因此它可能无法与其他配置一起正常工作。|
+| activeIn | 允许有选择地（取消）激活 txt2img、img2img 和两者的否定提示的脚本。|
+| maxResults | 最多显示多少个结果。对于默认标记集，结果按出现次数排序。对于嵌入和通配符，它​​将在可滚动列表中显示所有结果。 |
+| showAllResults | 如果为真，将忽略 maxResults 并在可滚动列表中显示所有结果。 **警告：** 对于长列表，您的浏览器可能会滞后。 |
+| resultStepLength | 允许以指定大小的小批次加载结果，以便在长列表中获得更好的性能，或者在showAllResults为真时。 |
+| delayTime | 指定在触发自动完成之前要等待多少毫秒。有助于防止打字时过于频繁的更新。 |
+| replaceUnderscores | 如果为 true，则在单击标签时将取消划线替换为空格。对于某些型号可能会更好。|
+| escapeParentheses | 如果为 true，则转义包含 () 的标签，因此它们不会对 Web UI 的提示权重功能做出贡献。 |
+| useWildcards | 用于切换通配符完成功能。 |
+| useEmbeddings | 用于切换嵌入完成功能。 |
+| alias | 标签别名的选项。更多信息在下面的部分。 |
+| translation | 用于翻译标签的选项。更多信息在下面的部分。 |
+| extras | 附加标签文件/翻译的选项。更多信息在下面的部分。|
+
+### colors.json (标签颜色)
+此外，标签类型的颜色可以使用扩展的`tags`文件夹中单独的`colors.json`文件来指定。
+你也可以在这里为自定义标签文件添加新的（与文件名相同，不带 .csv）。第一个值是暗模式，第二个值是亮模式。颜色名称和十六进制代码都被支持。
+```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)。
+
+### 别名，翻译&新增Tag
+#### 别名
+像Booru网站一样，标签可以有一个或多个别名，完成后重定向到实际值。这些将根据`config.json`中的设置进行搜索/显示。
+- `searchByAlias` - 是否也要搜索别名，或只搜索实际的标签。
+- `onlyShowAlias` - 只显示别名，不显示 `别名->实际`。仅用于显示，最后的文本仍然是实际的标签。
+
+#### 翻译
+可以在翻译部分添加一个额外的文件，它将被用来翻译标签和别名，同时也可以通过翻译进行搜索。
+这个文件需要是CSV格式的`<英语标签/别名>,<翻译>`，但为了向后兼容使用三栏格式的旧的额外文件，你可以打开`oldFormat`来代替它。
+
+完整和部分中文标签集的示例：
+
+![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文件
+额外文件可以用来添加未包含在主集中的新的/自定义标签。
+其格式与下面 [CSV tag data](#csv-tag-data) 中的正常标签格式相同，但有一个例外。
+由于自定义标签没有帖子计数，第三列（如果从零开始计算，则为第二列）用于显示标签旁边的灰色元文本。
+如果留空，它将显示 "Custom tag"。
+
+以默认的（非常基本的）extra-quality-tags.csv为例：
+
+![image](https://user-images.githubusercontent.com/34448969/218264276-cd77ba8e-62d8-41a2-b03c-6c04887ee18b.png)
+
+你可以在设置中选择自定义标签是否应该加在常规标签之前或之后。
+
+### CSV tag data
+本脚本的Tag文件格式如下，你可以安装这个格式制作自己的Tag文件：
+```csv
+1girl,0,4114588,"1girls,sole_female"
+solo,0,3426446,"female_solo,solo_female"
+highres,5,3008413,"high_res,high_resolution,hires"
+long_hair,0,2898315,longhair
+commentary_request,5,2610959,
+```
+值得注意的是，不希望在第一行有列名，而且count和aliases在技术上都是可选的。
+尽管count总是包含在默认数据中。多个别名也需要用逗号分隔，但要用字符串引号包裹，以免破坏CSV解析。
+编号系统遵循 Danbooru 的 [tag API docs](https://danbooru.donmai.us/wiki_pages/api%3Atags)：
+| Value	| Description |
+|-------|-------------|
+|0	    | General     |
+|1	    | Artist      |
+|3	    | Copyright   |
+|4	    | Character   |
+|5	    | Meta        |
+
+类似的还有e621：
+| Value	| Description |
+|-------|-------------|
+|-1	    | Invalid     |
+|0	    | General     |
+|1	    | Artist      |
+|3	    | Copyright   |
+|4	    | Character   |
+|5	    | Species     |
+|6	    | Invalid     |
+|7	    | Meta        |
+|8	    | Lore        |
+
+标记类型用于为结果列表中的条目着色.

a1111-sd-webui-tagcomplete/javascript/__globals.js

@@ -0,0 +1,52 @@
+// Core components
+var CFG = null;
+var tagBasePath = "";
+var keymap = null;
+
+// 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 = [];
+
+// Selected model info for black/whitelisting
+var currentModelHash = "";
+var currentModelName = "";
+
+// Current results
+var results = [];
+var resultCount = 0;
+
+// Relevant for parsing
+var previousTags = [];
+var tagword = "";
+var originalTagword = "";
+let hideBlocked = false;
+
+// Tag selection for keyboard navigation
+var selectedTag = null;
+var oldSelectedTag = null;
+
+// UMI
+var 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.
+
+// 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 = [];

a1111-sd-webui-tagcomplete/javascript/_baseParser.js

@@ -0,0 +1,21 @@
+class FunctionNotOverriddenError extends Error {
+    constructor(message = "", ...args) {
+        super(message, ...args);
+        this.message = message + " is an abstract base function and must be overwritten.";
+      }
+}
+
+class BaseTagParser {
+    triggerCondition = null;
+
+    constructor (triggerCondition) {
+        if (new.target === BaseTagParser) {
+            throw new TypeError("Cannot construct abstract BaseCompletionParser directly");
+        }
+        this.triggerCondition = triggerCondition;
+    }
+
+    parse() {
+        throw new FunctionNotOverriddenError("parse()");
+    }
+}

a1111-sd-webui-tagcomplete/javascript/_result.js

@@ -0,0 +1,32 @@
+// Result data type for cleaner use of optional completion result properties
+
+// Type enum
+const ResultType = Object.freeze({
+    "tag": 1,
+    "extra": 2,
+    "embedding": 3,
+    "wildcardTag": 4,
+    "wildcardFile": 5,
+    "yamlWildcard": 6,
+    "hypernetwork": 7,
+    "lora": 8
+});
+
+// Class to hold result data and annotations to make it clearer to use
+class AutocompleteResult {
+    // Main properties
+    text = "";
+    type = ResultType.tag;
+
+    // Additional info, only used in some cases
+    category = null;
+    count = null;
+    aliases = null;
+    meta = null;
+
+    // Constructor
+    constructor(text, type) {
+        this.text = text;
+        this.type = type;
+    }
+}

a1111-sd-webui-tagcomplete/javascript/_textAreas.js

@@ -0,0 +1,84 @@
+// 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"
+];
+
+// 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"
+        ]
+    }
+}
+
+function getTextAreas() {
+    // 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")];
+            
+            // 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;
+}
+
+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;
+}

a1111-sd-webui-tagcomplete/javascript/_utils.js

@@ -0,0 +1,130 @@
+// Utility functions for tag autocomplete
+
+// 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 (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 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 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) 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;
+    }
+
+    if (json)
+        return await response.json();
+    else
+        return await response.text();
+}
+
+// Load CSV
+async function loadCSV(path) {
+    let text = await readFile(path);
+    return parseCSV(text);
+}
+
+// Debounce function to prevent spamming the autocomplete function
+var dbTimeOut;
+const debounce = (func, wait = 300) => {
+    return function (...args) {
+        if (dbTimeOut) {
+            clearTimeout(dbTimeOut);
+        }
+
+        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;
+    }
+
+    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)), []);
+}
+
+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;
+}
+
+// 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;
+    }
+
+    let parseFunctions = matchingParsers.map(parser => parser.parse);
+    // Process them and return the results
+    return await processQueueReturn(parseFunctions, null, textArea, prompt);
+}

a1111-sd-webui-tagcomplete/javascript/ext_embeddings.js

@@ -0,0 +1,58 @@
+const EMB_REGEX = /<(?!l:|h:)[^,> ]*>?/g;
+const EMB_TRIGGER = () => CFG.useEmbeddings && tagword.match(EMB_REGEX);
+
+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);
+            }
+            if (versionString)
+                tempResults = embeddings.filter(x => x[0].toLowerCase().includes(searchTerm) && x[1] && x[1] === versionString); // Filter by tagword
+            else
+                tempResults = embeddings.filter(x => x[0].toLowerCase().includes(searchTerm)); // Filter by tagword
+        } else {
+            tempResults = embeddings;
+        }
+
+        // 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);
+        }
+    }
+}
+
+function sanitize(tagType, text) {
+    if (tagType === ResultType.embedding) {
+        return text.replace(/^.*?: /g, "");
+    }
+    return null;
+}
+
+PARSERS.push(new EmbeddingParser(EMB_TRIGGER));
+
+// Add our utility functions to their respective queues
+QUEUE_FILE_LOAD.push(load);
+QUEUE_SANITIZE.push(sanitize);

a1111-sd-webui-tagcomplete/javascript/ext_hypernets.js

@@ -0,0 +1,50 @@
+const HYP_REGEX = /<(?!e:|l:)[^,> ]*>?/g;
+const HYP_TRIGGER = () => CFG.useHypernetworks && 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("<", "");
+            tempResults = hypernetworks.filter(x => x.toLowerCase().includes(searchTerm)); // Filter by tagword
+        } else {
+            tempResults = hypernetworks;
+        }
+
+        // Add final results
+        let finalResults = [];
+        tempResults.forEach(t => {
+            let result = new AutocompleteResult(t.trim(), ResultType.hypernetwork)
+            result.meta = "Hypernetwork";
+            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);
+        }
+    }
+}
+
+function sanitize(tagType, text) {
+    if (tagType === ResultType.hypernetwork) {
+        return `<hypernet:${text}:${CFG.extraNetworksDefaultMultiplier}>`;
+    }
+    return null;
+}
+
+PARSERS.push(new HypernetParser(HYP_TRIGGER));
+
+// Add our utility functions to their respective queues
+QUEUE_FILE_LOAD.push(load);
+QUEUE_SANITIZE.push(sanitize);

a1111-sd-webui-tagcomplete/javascript/ext_loras.js

@@ -0,0 +1,50 @@
+const LORA_REGEX = /<(?!e:|h:)[^,> ]*>?/g;
+const LORA_TRIGGER = () => CFG.useLoras && 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("<", "");
+            tempResults = loras.filter(x => x.toLowerCase().includes(searchTerm)); // Filter by tagword
+        } else {
+            tempResults = loras;
+        }
+
+        // Add final results
+        let finalResults = [];
+        tempResults.forEach(t => {
+            let result = new AutocompleteResult(t.trim(), ResultType.lora)
+            result.meta = "Lora";
+            finalResults.push(result);
+        });
+
+        return finalResults;
+    }
+}
+
+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);
+        }
+    }
+}
+
+function sanitize(tagType, text) {
+    if (tagType === ResultType.lora) {
+        return `<lora:${text}:${CFG.extraNetworksDefaultMultiplier}>`;
+    }
+    return null;
+}
+
+PARSERS.push(new LoraParser(LORA_TRIGGER));
+
+// Add our utility functions to their respective queues
+QUEUE_FILE_LOAD.push(load);
+QUEUE_SANITIZE.push(sanitize);

a1111-sd-webui-tagcomplete/javascript/ext_umi.js

@@ -0,0 +1,240 @@
+const UMI_PROMPT_REGEX = /<[^\s]*?\[[^,<>]*[\]|]?>?/gi;
+const UMI_TAG_REGEX = /(?:\[|\||--)([^<>\[\]\-|]+)/gi;
+
+const UMI_TRIGGER = () => CFG.useWildcards && [...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 = []
+
+        const insertAt = (str,char,pos) => str.slice(0,pos) + char + str.slice(pos);
+
+        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);
+            }
+        });
+
+        // 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])
+                );
+        }
+        
+        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);
+            });
+
+            originalTagword = tagword;
+            tagword = "";
+            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)];
+
+        let umiTags = [];
+        umiSubPrompts.forEach(umiSubPrompt => {
+            umiTags = umiTags.concat([...umiSubPrompt[0].matchAll(UMI_TAG_REGEX)].map(x => x[1].toLowerCase()));
+        });
+
+        umiPreviousTags = umiTags;
+
+        hideResults(textArea);
+
+        return true;
+    }
+    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);
+        }
+    }
+}
+
+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("_", " "); 
+    }
+    return null;
+}
+
+// Add UMI parser
+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);

a1111-sd-webui-tagcomplete/javascript/ext_wildcards.js

@@ -0,0 +1,123 @@
+// Regex
+const WC_REGEX = /\b__([^,]+)__([^, ]*)\b/g;
+
+// Trigger conditions
+const WC_TRIGGER = () => CFG.useWildcards && [...tagword.matchAll(WC_REGEX)].length > 0;
+const WC_FILE_TRIGGER = () => CFG.useWildcards && (tagword.startsWith("__") && !tagword.endsWith("__") || tagword === "__");
+
+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];
+
+        // 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);
+
+        let wildcards = (await readFile(`${wcPair[0]}/${wcPair[1]}.txt`)).split("\n")
+            .filter(x => x.trim().length > 0 && !x.startsWith('#'));  // Remove empty lines and comments
+
+        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);
+        });
+
+        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);
+                }
+            }
+            // 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;
+
+                wcExtFile = wcExtFile.map(x => [base, x]);
+                wildcardExtFiles.push(...wcExtFile);
+            }
+        } catch (e) {
+            console.error("Error loading wildcards: " + e);
+        }
+    }
+}
+
+function sanitize(tagType, text) {
+    if (tagType === ResultType.wildcardFile) {
+        return `__${text}__`;
+    } else if (tagType === ResultType.wildcardTag) {
+        return text.replace(/^.*?: /g, "");
+    }
+    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; }, 100);
+        return true;
+    }
+    return false;
+}
+
+// Register the parsers
+PARSERS.push(new WildcardParser(WC_TRIGGER));
+PARSERS.push(new WildcardFileParser(WC_FILE_TRIGGER));
+
+// Add our utility functions to their respective queues
+QUEUE_FILE_LOAD.push(load);
+QUEUE_SANITIZE.push(sanitize);
+QUEUE_AFTER_INSERT.push(keepOpenIfWildcard);

a1111-sd-webui-tagcomplete/javascript/tagAutocomplete.js

@@ -0,0 +1,909 @@
+const styleColors = {
+    "--results-bg": ["#0b0f19", "#ffffff"],
+    "--results-border-color": ["#4b5563", "#e5e7eb"],
+    "--results-border-width": ["1px", "1.5px"],
+    "--results-bg-odd": ["#111827", "#f9fafb"],
+    "--results-hover": ["#1f2937", "#f5f6f8"],
+    "--results-selected": ["#374151", "#e5e7eb"],
+    "--meta-text-color": ["#6b6f7b", "#a2a9b4"],
+    "--embedding-v1-color": ["lightsteelblue", "#2b5797"],
+    "--embedding-v2-color": ["skyblue", "#2d89ef"],
+}
+const browserVars = {
+    "--results-overflow-y": {
+        "firefox": "scroll",
+        "other": "auto"
+    }
+}
+// Style for new elements. Gets appended to the Gradio root.
+const autocompleteCSS = `
+    #quicksettings [id^=setting_tac] {
+        background-color: transparent;
+        min-width: fit-content;
+        align-self: center;
+    }
+    #quicksettings [id^=setting_tac] > label > span {
+        margin-bottom: 0px;
+    }
+    [id^=refresh_tac] {
+        max-width: 2.5em;
+        min-width: 2.5em;
+        height: 2.4em;
+    }
+    .autocompleteResults {
+        position: absolute;
+        z-index: 999;
+        max-width: calc(100% - 1.5rem);
+        margin: 5px 0 0 0;
+        background-color: var(--results-bg) !important;
+        border: var(--results-border-width) solid var(--results-border-color) !important;
+        border-radius: 12px !important;
+        overflow-y: var(--results-overflow-y);
+        overflow-x: hidden;
+        word-break: break-word;
+    }
+    .autocompleteResultsList > li:nth-child(odd) {
+        background-color: var(--results-bg-odd);
+    }
+    .autocompleteResultsList > li {
+        list-style-type: none;
+        padding: 10px;
+        cursor: pointer;
+    }
+    .autocompleteResultsList > li:hover {
+        background-color: var(--results-hover);
+    }
+    .autocompleteResultsList > li.selected {
+        background-color: var(--results-selected);
+    }
+    .resultsFlexContainer {
+        display: flex;
+    }
+    .acListItem {
+        white-space: break-spaces;
+    }
+    .acMetaText {
+        position: relative;
+        flex-grow: 1;
+        text-align: end;
+        padding: 0 0 0 15px;
+        white-space: nowrap;
+        color: var(--meta-text-color);
+    }
+    .acWikiLink {
+        padding: 0.5rem;
+        margin: -0.5rem 0 -0.5rem -0.5rem;
+    }
+    .acWikiLink:hover {
+        text-decoration: underline;
+    }
+    .acListItem.acEmbeddingV1 {
+        color: var(--embedding-v1-color);
+    }
+    .acListItem.acEmbeddingV2 {
+        color: var(--embedding-v2-color);
+    }
+`;
+
+async function loadTags(c) {
+    // Load main tags and aliases
+    if (allTags.length === 0 && c.tagFile && c.tagFile !== "None") {
+        try {
+            allTags = await loadCSV(`${tagBasePath}/${c.tagFile}`);
+        } catch (e) {
+            console.error("Error loading tags file: " + e);
+            return;
+        }
+    }
+    if (c.extra.extraFile && c.extra.extraFile !== "None") {
+        try {
+            extras = await loadCSV(`${tagBasePath}/${c.extra.extraFile}`);
+        } catch (e) {
+            console.error("Error loading extra file: " + e);
+            return;
+        }
+    }
+}
+
+async function loadTranslations(c) {
+    if (c.translation.translationFile && c.translation.translationFile !== "None") {
+        try {
+            let tArray = await loadCSV(`${tagBasePath}/${c.translation.translationFile}`);
+            tArray.forEach(t => {
+                if (c.translation.oldFormat)
+                    translations.set(t[0], t[2]);
+                else
+                    translations.set(t[0], t[1]);
+            });
+        } catch (e) {
+            console.error("Error loading translations file: " + e);
+            return;
+        }
+    }
+}
+
+async function syncOptions() {
+    let newCFG = {
+        // Main tag file
+        tagFile: opts["tac_tagFile"],
+        // Active in settings
+        activeIn: {
+            global: opts["tac_active"],
+            txt2img: opts["tac_activeIn.txt2img"],
+            img2img: opts["tac_activeIn.img2img"],
+            negativePrompts: opts["tac_activeIn.negativePrompts"],
+            thirdParty: opts["tac_activeIn.thirdParty"],
+            modelList: opts["tac_activeIn.modelList"],
+            modelListMode: opts["tac_activeIn.modelListMode"]
+        },
+        // Results related settings
+        maxResults: opts["tac_maxResults"],
+        showAllResults: opts["tac_showAllResults"],
+        resultStepLength: opts["tac_resultStepLength"],
+        delayTime: opts["tac_delayTime"],
+        useWildcards: opts["tac_useWildcards"],
+        useEmbeddings: opts["tac_useEmbeddings"],
+        useHypernetworks: opts["tac_useHypernetworks"],
+        useLoras: opts["tac_useLoras"],
+        showWikiLinks: opts["tac_showWikiLinks"],
+        // Insertion related settings
+        replaceUnderscores: opts["tac_replaceUnderscores"],
+        escapeParentheses: opts["tac_escapeParentheses"],
+        appendComma: opts["tac_appendComma"],
+        // Alias settings
+        alias: {
+            searchByAlias: opts["tac_alias.searchByAlias"],
+            onlyShowAlias: opts["tac_alias.onlyShowAlias"]
+        },
+        // Translation settings
+        translation: {
+            translationFile: opts["tac_translation.translationFile"],
+            oldFormat: opts["tac_translation.oldFormat"],
+            searchByTranslation: opts["tac_translation.searchByTranslation"],
+        },
+        // Extra file settings
+        extra: {
+            extraFile: opts["tac_extra.extraFile"],
+            addMode: opts["tac_extra.addMode"]
+        },
+        // Settings not from tac but still used by the script
+        extraNetworksDefaultMultiplier: opts["extra_networks_default_multiplier"]
+    }
+
+    if (CFG && CFG.colors) {
+        newCFG["colors"] = CFG.colors;
+    }
+    if (newCFG.alias.onlyShowAlias) {
+        newCFG.alias.searchByAlias = true; // if only show translation, enable search by translation is necessary
+    }
+
+    // Reload tags if the tag file changed
+    if (!CFG || newCFG.tagFile !== CFG.tagFile || newCFG.extra.extraFile !== CFG.extra.extraFile) {
+        allTags = [];
+        await loadTags(newCFG);
+    }
+    // Reload translations if the translation file changed
+    if (!CFG || newCFG.translation.translationFile !== CFG.translation.translationFile) {
+        translations.clear();
+        await loadTranslations(newCFG);
+    }
+
+    // Update CSS if maxResults changed
+    if (CFG && newCFG.maxResults !== CFG.maxResults) {
+        gradioApp().querySelectorAll(".autocompleteResults").forEach(r => {
+            r.style.maxHeight = `${newCFG.maxResults * 50}px`;
+        });
+    }
+
+    // Apply changes
+    CFG = newCFG;
+
+    // Callback
+    await processQueue(QUEUE_AFTER_CONFIG_CHANGE, null);
+}
+
+// Create the result list div and necessary styling
+function createResultsDiv(textArea) {
+    let resultsDiv = document.createElement("div");
+    let resultsList = document.createElement('ul');
+
+    let textAreaId = getTextAreaIdentifier(textArea);
+    let typeClass = textAreaId.replaceAll(".", " ");
+
+    resultsDiv.style.maxHeight = `${CFG.maxResults * 50}px`;
+    resultsDiv.setAttribute('class', `autocompleteResults ${typeClass}`);
+    resultsList.setAttribute('class', 'autocompleteResultsList');
+    resultsDiv.appendChild(resultsList);
+
+    return resultsDiv;
+}
+
+// Show or hide the results div
+function isVisible(textArea) {
+    let textAreaId = getTextAreaIdentifier(textArea);
+    let resultsDiv = gradioApp().querySelector('.autocompleteResults' + textAreaId);
+    return resultsDiv.style.display === "block";
+}
+function showResults(textArea) {
+    let textAreaId = getTextAreaIdentifier(textArea);
+    let resultsDiv = gradioApp().querySelector('.autocompleteResults' + textAreaId);
+    resultsDiv.style.display = "block";
+}
+function hideResults(textArea) {
+    let textAreaId = getTextAreaIdentifier(textArea);
+    let resultsDiv = gradioApp().querySelector('.autocompleteResults' + textAreaId);
+    resultsDiv.style.display = "none";
+    selectedTag = null;
+}
+
+// Function to check activation criteria
+function isEnabled() {
+    if (CFG.activeIn.global) {
+        let modelList = CFG.activeIn.modelList
+            .split(",")
+            .map(x => x.trim())
+            .filter(x => x.length > 0);
+        
+        let shortHash = currentModelHash.substring(0, 10);
+        if (CFG.activeIn.modelListMode.toLowerCase() === "blacklist") {
+            // If the current model is in the blacklist, disable
+            return modelList.filter(x => x === currentModelName || x === currentModelHash || x === shortHash).length === 0;
+        } else {
+            // If the current model is in the whitelist, enable.
+            // An empty whitelist is ignored.
+            return modelList.length === 0 || modelList.filter(x => x === currentModelName || x === currentModelHash || x === shortHash).length > 0;
+        }
+    } else {
+        return false;
+    }
+}
+
+const WEIGHT_REGEX = /[([]([^,()[\]:| ]+)(?::(?:\d+(?:\.\d+)?|\.\d+))?[)\]]/g;
+const POINTY_REGEX = /<[^\s,<](?:[^\t\n\r,<>]*>|[^\t\n\r,> ]*)/g;
+const COMPLETED_WILDCARD_REGEX = /__[^\s,_][^\t\n\r,_]*[^\s,_]__[^\s,_]*/g;
+const NORMAL_TAG_REGEX = /[^\s,|<>]+|</g;
+const TAG_REGEX = new RegExp(`${POINTY_REGEX.source}|${COMPLETED_WILDCARD_REGEX.source}|${NORMAL_TAG_REGEX.source}`, "g");
+
+// On click, insert the tag into the prompt textbox with respect to the cursor position
+async function insertTextAtCursor(textArea, result, tagword) {
+    let text = result.text;
+    let tagType = result.type;
+
+    let cursorPos = textArea.selectionStart;
+    var sanitizedText = text
+
+    // Run sanitize queue and use first result as sanitized text
+    sanitizeResults = await processQueueReturn(QUEUE_SANITIZE, null, tagType, text);
+
+    if (sanitizeResults && sanitizeResults.length > 0) {
+        sanitizedText = sanitizeResults[0];
+    } else {
+        sanitizedText = CFG.replaceUnderscores ? text.replaceAll("_", " ") : text;
+
+        if (CFG.escapeParentheses && tagType === ResultType.tag) {
+            sanitizedText = sanitizedText
+                .replaceAll("(", "\\(")
+                .replaceAll(")", "\\)")
+                .replaceAll("[", "\\[")
+                .replaceAll("]", "\\]");
+        }
+    }
+
+    var prompt = textArea.value;
+
+    // Edit prompt text
+    let editStart = Math.max(cursorPos - tagword.length, 0);
+    let editEnd = Math.min(cursorPos + tagword.length, prompt.length);
+    let surrounding = prompt.substring(editStart, editEnd);
+    let match = surrounding.match(new RegExp(escapeRegExp(`${tagword}`), "i"));
+    let afterInsertCursorPos = editStart + match.index + sanitizedText.length;
+
+    var optionalComma = "";
+    if (CFG.appendComma && ![ResultType.wildcardFile, ResultType.yamlWildcard].includes(tagType)) {
+        optionalComma = surrounding.match(new RegExp(`${escapeRegExp(tagword)}[,:]`, "i")) !== null ? "" : ", ";
+    }
+
+    // Replace partial tag word with new text, add comma if needed
+    let insert = surrounding.replace(match, sanitizedText + optionalComma);
+
+    // Add back start
+    var newPrompt = prompt.substring(0, editStart) + insert + prompt.substring(editEnd);
+    textArea.value = newPrompt;
+    textArea.selectionStart = afterInsertCursorPos + optionalComma.length;
+    textArea.selectionEnd = textArea.selectionStart
+
+    // Since we've modified a Gradio Textbox component manually, we need to simulate an `input` DOM event to ensure it's propagated back to python.
+    // Uses a built-in method from the webui's ui.js which also already accounts for event target
+    updateInput(textArea);
+
+    // Update previous tags with the edited prompt to prevent re-searching the same term
+    let weightedTags = [...newPrompt.matchAll(WEIGHT_REGEX)]
+            .map(match => match[1]);
+    let tags = newPrompt.match(TAG_REGEX)
+    if (weightedTags !== null) {
+        tags = tags.filter(tag => !weightedTags.some(weighted => tag.includes(weighted)))
+            .concat(weightedTags);
+    }
+    previousTags = tags;
+
+    // Callback
+    let returns = await processQueueReturn(QUEUE_AFTER_INSERT, null, tagType, sanitizedText, newPrompt, textArea);
+    // Return if any queue function returned true (has handled hide/show already)
+    if (returns.some(x => x === true))
+        return;
+
+    // Hide results after inserting, if it hasn't been hidden already by a queue function
+    if (!hideBlocked && isVisible(textArea)) {
+        hideResults(textArea);
+    }
+}
+
+function addResultsToList(textArea, results, tagword, resetList) {
+    let textAreaId = getTextAreaIdentifier(textArea);
+    let resultDiv = gradioApp().querySelector('.autocompleteResults' + textAreaId);
+    let resultsList = resultDiv.querySelector('ul');
+
+    // Reset list, selection and scrollTop since the list changed
+    if (resetList) {
+        resultsList.innerHTML = "";
+        selectedTag = null;
+        resultDiv.scrollTop = 0;
+        resultCount = 0;
+    }
+
+    // Find right colors from config
+    let tagFileName = CFG.tagFile.split(".")[0];
+    let tagColors = CFG.colors;
+    let mode = gradioApp().querySelector('.dark') ? 0 : 1;
+    let nextLength = Math.min(results.length, resultCount + CFG.resultStepLength);
+
+    for (let i = resultCount; i < nextLength; i++) {
+        let result = results[i];
+
+        // Skip if the result is null or undefined
+        if (!result)
+            continue;
+
+        let li = document.createElement("li");
+
+        let flexDiv = document.createElement("div");
+        flexDiv.classList.add("resultsFlexContainer");
+        li.appendChild(flexDiv);
+
+        let itemText = document.createElement("div");
+        itemText.classList.add("acListItem");
+
+        let displayText = "";
+        // If the tag matches the tagword, we don't need to display the alias
+        if (result.aliases && !result.text.includes(tagword)) { // Alias
+            let splitAliases = result.aliases.split(",");
+            let bestAlias = splitAliases.find(a => a.toLowerCase().includes(tagword));
+
+            // search in translations if no alias matches
+            if (!bestAlias) {
+                let tagOrAlias = pair => pair[0] === result.text || splitAliases.includes(pair[0]);
+                var tArray = [...translations];
+                if (tArray) {
+                    var translationKey = [...translations].find(pair => tagOrAlias(pair) && pair[1].includes(tagword));
+                    if (translationKey)
+                        bestAlias = translationKey[0];
+                }
+            }
+
+            displayText = escapeHTML(bestAlias);
+
+            // Append translation for alias if it exists and is not what the user typed
+            if (translations.has(bestAlias) && translations.get(bestAlias) !== bestAlias && bestAlias !== result.text)
+                displayText += `[${translations.get(bestAlias)}]`;
+
+            if (!CFG.alias.onlyShowAlias && result.text !== bestAlias)
+                displayText += " ➝ " + result.text;
+        } else { // No alias
+            displayText = escapeHTML(result.text);
+        }
+
+        // Append translation for result if it exists
+        if (translations.has(result.text))
+            displayText += `  →   ${translations.get(result.text)}`;
+
+        // Print search term bolded in result
+        itemText.innerHTML = displayText.replace(tagword, `<b>${tagword}</b>`);
+
+        // Add wiki link if the setting is enabled and a supported tag set loaded
+        if (CFG.showWikiLinks
+            && (result.type === ResultType.tag)
+            && (tagFileName.toLowerCase().startsWith("danbooru") || tagFileName.toLowerCase().startsWith("e621"))) {
+            let wikiLink = document.createElement("a");
+            wikiLink.classList.add("acWikiLink");
+            wikiLink.innerText = "?";
+
+            let linkPart = displayText;
+            // Only use alias result if it is one
+            if (displayText.includes("➝"))
+                linkPart = displayText.split(" ➝ ")[1];
+            
+            // Set link based on selected file
+            let tagFileNameLower = tagFileName.toLowerCase();
+            if (tagFileNameLower.startsWith("danbooru")) {
+                wikiLink.href = `https://danbooru.donmai.us/wiki_pages/${linkPart}`;
+            } else if (tagFileNameLower.startsWith("e621")) {
+                wikiLink.href = `https://e621.net/wiki_pages/${linkPart}`;
+            }
+            
+            wikiLink.target = "_blank";
+            flexDiv.appendChild(wikiLink);
+        }
+
+        flexDiv.appendChild(itemText);
+
+        // Add post count & color if it's a tag
+        // Wildcards & Embeds have no tag category
+        if (result.category) {
+            // Set the color of the tag
+            let cat = result.category;
+            let colorGroup = tagColors[tagFileName];
+            // Default to danbooru scheme if no matching one is found
+            if (!colorGroup)
+                colorGroup = tagColors["danbooru"];
+
+            // Set tag type to invalid if not found
+            if (!colorGroup[cat])
+                cat = "-1";
+
+            flexDiv.style = `color: ${colorGroup[cat][mode]};`;
+        }
+
+        // Post count
+        if (result.count && !isNaN(result.count)) {
+            let postCount = result.count;
+            let formatter;
+
+            // Danbooru formats numbers with a padded fraction for 1M or 1k, but not for 10/100k
+            if (postCount >= 1000000 || (postCount >= 1000 && postCount < 10000))
+                formatter = Intl.NumberFormat("en", { notation: "compact", minimumFractionDigits: 1, maximumFractionDigits: 1 });
+            else
+                formatter = Intl.NumberFormat("en", {notation: "compact"});
+
+            let formattedCount = formatter.format(postCount);
+
+            let countDiv = document.createElement("div");
+            countDiv.textContent = formattedCount;
+            countDiv.classList.add("acMetaText");
+            flexDiv.appendChild(countDiv);
+        } else if (result.meta) { // Check if there is meta info to display
+            let metaDiv = document.createElement("div");
+            metaDiv.textContent = result.meta;
+            metaDiv.classList.add("acMetaText");
+
+            // Add version info classes if it is an embedding
+            if (result.type === ResultType.embedding) {
+                if (result.meta.startsWith("v1"))
+                    itemText.classList.add("acEmbeddingV1");
+                else if (result.meta.startsWith("v2"))
+                    itemText.classList.add("acEmbeddingV2");
+            }
+                
+            flexDiv.appendChild(metaDiv);
+        }
+
+        // Add listener
+        li.addEventListener("click", function () { insertTextAtCursor(textArea, result, tagword); });
+        // Add element to list
+        resultsList.appendChild(li);
+    }
+    resultCount = nextLength;
+
+    if (resetList)
+        resultDiv.scrollTop = 0;
+}
+
+function updateSelectionStyle(textArea, newIndex, oldIndex) {
+    let textAreaId = getTextAreaIdentifier(textArea);
+    let resultDiv = gradioApp().querySelector('.autocompleteResults' + textAreaId);
+    let resultsList = resultDiv.querySelector('ul');
+    let items = resultsList.getElementsByTagName('li');
+
+    if (oldIndex != null) {
+        items[oldIndex].classList.remove('selected');
+    }
+
+    // make it safer
+    if (newIndex !== null) {
+        items[newIndex].classList.add('selected');
+    }
+
+    // Set scrolltop to selected item if we are showing more than max results
+    if (items.length > CFG.maxResults) {
+        let selected = items[newIndex];
+        resultDiv.scrollTop = selected.offsetTop - resultDiv.offsetTop;
+    }
+}
+
+async function autocomplete(textArea, prompt, fixedTag = null) {
+    // Return if the function is deactivated in the UI
+    if (!isEnabled()) return;
+
+    // Guard for empty prompt
+    if (prompt.length === 0) {
+        hideResults(textArea);
+        previousTags = [];
+        tagword = "";
+        return;
+    }
+
+    if (fixedTag === null) {
+        // Match tags with RegEx to get the last edited one
+        // We also match for the weighting format (e.g. "tag:1.0") here, and combine the two to get the full tag word set
+        let weightedTags = [...prompt.matchAll(WEIGHT_REGEX)]
+            .map(match => match[1]);
+        let tags = prompt.match(TAG_REGEX)
+        if (weightedTags !== null && tags !== null) {
+            tags = tags.filter(tag => !weightedTags.some(weighted => tag.includes(weighted) && !tag.startsWith("<[")))
+                .concat(weightedTags);
+        }
+
+        // Guard for no tags
+        if (!tags || tags.length === 0) {
+            previousTags = [];
+            tagword = "";
+            hideResults(textArea);
+            return;
+        }
+
+        let tagCountChange = tags.length - previousTags.length;
+        let diff = difference(tags, previousTags);
+        previousTags = tags;
+
+        // Guard for no difference / only whitespace remaining / last edited tag was fully removed
+        if (diff === null || diff.length === 0 || (diff.length === 1 && tagCountChange < 0)) {
+            if (!hideBlocked) hideResults(textArea);
+            return;
+        }
+
+        tagword = diff[0]
+
+        // Guard for empty tagword
+        if (tagword === null || tagword.length === 0) {
+            hideResults(textArea);
+            return;
+        }
+    } else {
+        tagword = fixedTag;
+    }
+
+    results = [];
+    tagword = tagword.toLowerCase().replace(/[\n\r]/g, "");
+
+    // Process all parsers
+    let resultCandidates = await processParsers(textArea, prompt);
+    // If one ore more result candidates match, use their results
+    if (resultCandidates && resultCandidates.length > 0) {
+        // Flatten our candidate(s)
+        results = resultCandidates.flat();
+        // If there was more than one candidate, sort the results by text to mix them
+        // instead of having them added in the order of the parsers
+        let shouldSort = resultCandidates.length > 1;
+        if (shouldSort) {
+            results = results.sort((a, b) => a.text.localeCompare(b.text));
+
+            // Since some tags are kaomoji, we have to add the normal results in some cases
+            if (tagword.startsWith("<") || tagword.startsWith("*<")) {
+                // Create escaped search regex with support for * as a start placeholder
+                let searchRegex;
+                if (tagword.startsWith("*")) {
+                    tagword = tagword.slice(1);
+                    searchRegex = new RegExp(`${escapeRegExp(tagword)}`, 'i');
+                } else {
+                    searchRegex = new RegExp(`(^|[^a-zA-Z])${escapeRegExp(tagword)}`, 'i');
+                }
+                let genericResults = allTags.filter(x => x[0].toLowerCase().search(searchRegex) > -1).slice(0, CFG.maxResults);
+
+                genericResults.forEach(g => {
+                    let result = new AutocompleteResult(g[0].trim(), ResultType.tag)
+                    result.category = g[1];
+                    result.count = g[2];
+                    result.aliases = g[3];
+                    results.push(result);
+                });
+            }
+        }
+    } else { // Else search the normal tag list
+        // Create escaped search regex with support for * as a start placeholder
+        let searchRegex;
+        if (tagword.startsWith("*")) {
+            tagword = tagword.slice(1);
+            searchRegex = new RegExp(`${escapeRegExp(tagword)}`, 'i');
+        } else {
+            searchRegex = new RegExp(`(^|[^a-zA-Z])${escapeRegExp(tagword)}`, 'i');
+        }    
+        // If onlyShowAlias is enabled, we don't need to include normal results
+        if (CFG.alias.onlyShowAlias) {
+            results = allTags.filter(x => x[3] && x[3].toLowerCase().search(searchRegex) > -1);
+        } else {
+            // Else both normal tags and aliases/translations are included depending on the config
+            let baseFilter = (x) => x[0].toLowerCase().search(searchRegex) > -1;
+            let aliasFilter = (x) => x[3] && x[3].toLowerCase().search(searchRegex) > -1;
+            let translationFilter = (x) => (translations.has(x[0]) && translations.get(x[0]).toLowerCase().search(searchRegex) > -1)
+                || x[3] && x[3].split(",").some(y => translations.has(y) && translations.get(y).toLowerCase().search(searchRegex) > -1);
+            
+            let fil;
+            if (CFG.alias.searchByAlias && CFG.translation.searchByTranslation)
+                fil = (x) => baseFilter(x) || aliasFilter(x) || translationFilter(x);
+            else if (CFG.alias.searchByAlias && !CFG.translation.searchByTranslation)
+                fil = (x) => baseFilter(x) || aliasFilter(x);
+            else if (CFG.translation.searchByTranslation && !CFG.alias.searchByAlias)
+                fil = (x) => baseFilter(x) || translationFilter(x);
+            else
+                fil = (x) => baseFilter(x);
+
+            // Add final results
+            allTags.filter(fil).forEach(t => {
+                let result = new AutocompleteResult(t[0].trim(), ResultType.tag)
+                result.category = t[1];
+                result.count = t[2];
+                result.aliases = t[3];
+                results.push(result);
+            });
+
+            // Add extras
+            if (CFG.extra.extraFile) {
+                let extraResults = [];
+
+                extras.filter(fil).forEach(e => {
+                    let result = new AutocompleteResult(e[0].trim(), ResultType.extra)
+                    result.category = e[1] || 0; // If no category is given, use 0 as the default
+                    result.meta = e[2] || "Custom tag";
+                    result.aliases = e[3] || "";
+                    extraResults.push(result);
+                });
+
+                if (CFG.extra.addMode === "Insert before") {
+                    results = extraResults.concat(results);
+                } else {
+                    results = results.concat(extraResults);
+                }
+            }
+        }
+        // Slice if the user has set a max result count
+        if (!CFG.showAllResults) {
+            results = results.slice(0, CFG.maxResults);
+        }
+    }
+
+    // Guard for empty results
+    if (!results || results.length === 0) {
+        //console.log('No results found for "' + tagword + '"');
+        hideResults(textArea);
+        return;
+    }
+
+    addResultsToList(textArea, results, tagword, true);
+    showResults(textArea);
+}
+
+function navigateInList(textArea, event) {
+    // Return if the function is deactivated in the UI or the current model is excluded due to white/blacklist settings
+    if (!isEnabled()) return;
+
+    // Close window if Home or End is pressed while not a keybinding, since it would break completion on leaving the original tag
+    if ((event.key === "Home" || event.key === "End") && !Object.values(keymap).includes(event.key)) {
+        hideResults(textArea);
+        return;
+    }
+
+    // All set keys that are not None or empty are valid
+    // Default keys are: ArrowUp, ArrowDown, PageUp, PageDown, Home, End, Enter, Tab, Escape
+    validKeys = Object.values(keymap).filter(x => x !== "None" && x !== "");
+
+    if (!validKeys.includes(event.key)) return;
+    if (!isVisible(textArea)) return
+    // Return if ctrl key is pressed to not interfere with weight editing shortcut
+    if (event.ctrlKey || event.altKey) return;
+
+    oldSelectedTag = selectedTag;
+
+    switch (event.key) {
+        case keymap["MoveUp"]:
+            if (selectedTag === null) {
+                selectedTag = resultCount - 1;
+            } else {
+                selectedTag = (selectedTag - 1 + resultCount) % resultCount;
+            }
+            break;
+        case keymap["MoveDown"]:
+            if (selectedTag === null) {
+                selectedTag = 0;
+            } else {
+                selectedTag = (selectedTag + 1) % resultCount;
+            }
+            break;
+        case keymap["JumpUp"]:
+            if (selectedTag === null || selectedTag === 0) {
+                selectedTag = resultCount - 1;
+            } else {
+                selectedTag = (Math.max(selectedTag - 5, 0) + resultCount) % resultCount;
+            }
+            break;
+        case keymap["JumpDown"]:
+            if (selectedTag === null || selectedTag === resultCount - 1) {
+                selectedTag = 0;
+            } else {
+                selectedTag = Math.min(selectedTag + 5, resultCount - 1) % resultCount;
+            }
+            break;
+        case keymap["JumpToStart"]:
+            selectedTag = 0;
+            break;
+        case keymap["JumpToEnd"]:
+            selectedTag = resultCount - 1;
+            break;
+        case keymap["ChooseSelected"]:
+            if (selectedTag !== null) {
+                insertTextAtCursor(textArea, results[selectedTag], tagword);
+            }
+            break;
+        case keymap["ChooseFirstOrSelected"]:
+            if (selectedTag === null) {
+                selectedTag = 0;
+            }
+            insertTextAtCursor(textArea, results[selectedTag], tagword);
+            break;
+        case keymap["Close"]:
+            hideResults(textArea);
+            break;
+    }
+    if (selectedTag === resultCount - 1
+        && (event.key === keymap["MoveUp"] || event.key === keymap["MoveDown"] || event.key === keymap["JumpToStart"] || event.key === keymap["JumpToEnd"])) {
+        addResultsToList(textArea, results, tagword, false);
+    }
+    // Update highlighting
+    if (selectedTag !== null)
+        updateSelectionStyle(textArea, selectedTag, oldSelectedTag);
+
+    // Prevent default behavior
+    event.preventDefault();
+    event.stopPropagation();
+}
+
+// One-time setup, triggered from onUiUpdate
+async function setup() {
+    // Load key bindings
+    keymap = (await readFile(`${tagBasePath}/keymap.json`, true));
+    
+    // Load colors
+    CFG["colors"] = (await readFile(`${tagBasePath}/colors.json`, true));
+
+    // Load external files needed by completion extensions
+    await processQueue(QUEUE_FILE_LOAD, null);
+
+    // Find all textareas
+    let textAreas = getTextAreas();
+
+    // Add event listener to apply settings button so we can mirror the changes to our internal config
+    let applySettingsButton = gradioApp().querySelector("#tab_settings #settings_submit") || gradioApp().querySelector("#tab_settings > div > .gr-button-primary");
+    applySettingsButton?.addEventListener("click", () => {
+        // Wait 500ms to make sure the settings have been applied to the webui opts object
+        setTimeout(async () => { 
+            await syncOptions();
+        }, 500);
+    });
+    // Add change listener to our quicksettings to change our internal config without the apply button for them
+    let quicksettings = gradioApp().querySelector('#quicksettings');
+    let commonQueryPart = "[id^=setting_tac] > label >";
+    quicksettings?.querySelectorAll(`${commonQueryPart} input, ${commonQueryPart} textarea, ${commonQueryPart} select`).forEach(e => {
+        e.addEventListener("change", () => {
+            setTimeout(async () => { 
+                await syncOptions();
+            }, 500);
+        });
+    });
+
+    // Add change listener to model dropdown to react to model changes
+    let modelDropdown = gradioApp().querySelector("#setting_sd_model_checkpoint select");
+    currentModelName = modelDropdown.value;
+    modelDropdown?.addEventListener("change", () => {
+        setTimeout(() => {
+            currentModelName = modelDropdown.value;
+        }, 100);
+    });
+    // Add mutation observer for the model hash text to also allow hash-based blacklist again
+    let modelHashText = gradioApp().querySelector("#sd_checkpoint_hash");
+    if (modelHashText) {
+        currentModelHash = modelHashText.title
+        let modelHashObserver = new MutationObserver((mutationList, observer) => {
+            for (const mutation of mutationList) {
+                if (mutation.type === "attributes" && mutation.attributeName === "title") {
+                    currentModelHash = mutation.target.title;
+                }
+            }
+        });
+        modelHashObserver.observe(modelHashText, { attributes: true });
+    }
+
+    // Not found, we're on a page without prompt textareas
+    if (textAreas.every(v => v === null || v === undefined)) return;
+    // Already added or unnecessary to add
+    if (gradioApp().querySelector('.autocompleteResults.p')) {
+        if (gradioApp().querySelector('.autocompleteResults.n') || !CFG.activeIn.negativePrompts) {
+            return;
+        }
+    } else if (!CFG.activeIn.txt2img && !CFG.activeIn.img2img) {
+        return;
+    }
+
+    textAreas.forEach(area => {
+        // Return if autocomplete is disabled for the current area type in config
+        let textAreaId = getTextAreaIdentifier(area);
+        if ((!CFG.activeIn.img2img && textAreaId.includes("img2img"))
+            || (!CFG.activeIn.txt2img && textAreaId.includes("txt2img"))
+            || (!CFG.activeIn.negativePrompts && textAreaId.includes("n"))
+            || (!CFG.activeIn.thirdParty && textAreaId.includes("thirdParty"))) {
+            return;
+        }
+
+        // Only add listeners once
+        if (!area.classList.contains('autocomplete')) {
+            // Add our new element
+            var resultsDiv = createResultsDiv(area);
+            area.parentNode.insertBefore(resultsDiv, area.nextSibling);
+            // Hide by default so it doesn't show up on page load
+            hideResults(area);
+
+            // Add autocomplete event listener
+            area.addEventListener('input', debounce(() => autocomplete(area, area.value), CFG.delayTime));
+            // Add focusout event listener
+            area.addEventListener('focusout', debounce(() => hideResults(area), 400));
+            // Add up and down arrow event listener
+            area.addEventListener('keydown', (e) => navigateInList(area, e));
+            // CompositionEnd fires after the user has finished IME composing
+            // We need to block hide here to prevent the enter key from insta-closing the results
+            area.addEventListener('compositionend', () => {
+                hideBlocked = true;
+                setTimeout(() => { hideBlocked = false; }, 100);
+            });
+
+            // Add class so we know we've already added the listeners
+            area.classList.add('autocomplete');
+        }
+    });
+
+    // Add style to dom
+    let acStyle = document.createElement('style');
+    //let css = gradioApp().querySelector('.dark') ? autocompleteCSS_dark : autocompleteCSS_light;
+    let mode = gradioApp().querySelector('.dark') ? 0 : 1;
+    // Check if we are on webkit
+    let browser = navigator.userAgent.toLowerCase().indexOf('firefox') > -1 ? "firefox" : "other";
+    
+    let css = autocompleteCSS;
+    // Replace vars with actual values (can't use actual css vars because of the way we inject the css)
+    Object.keys(styleColors).forEach((key) => {
+        css = css.replace(`var(${key})`, styleColors[key][mode]);
+    })
+    Object.keys(browserVars).forEach((key) => {
+        css = css.replace(`var(${key})`, browserVars[key][browser]);
+    })
+    
+    if (acStyle.styleSheet) {
+        acStyle.styleSheet.cssText = css;
+    } else {
+        acStyle.appendChild(document.createTextNode(css));
+    }
+    gradioApp().appendChild(acStyle);
+
+    // Callback
+    await processQueue(QUEUE_AFTER_SETUP, null);
+}
+let loading = false;
+onUiUpdate(async () => {
+    if (loading) return;
+    if (Object.keys(opts).length === 0) return;
+    if (CFG) return;
+    loading = true;
+    // Get our tag base path from the temp file
+    tagBasePath = await readFile(`tmp/tagAutocompletePath.txt`);
+    // Load config from webui opts
+    await syncOptions();
+    // Rest of setup
+    setup();
+    loading = false;
+});

a1111-sd-webui-tagcomplete/scripts/tag_autocomplete_helper.py

@@ -0,0 +1,280 @@
+# This helper script scans folders for wildcards and embeddings and writes them
+# to a temporary file to expose it to the javascript side
+
+import gradio as gr
+from pathlib import Path
+from modules import scripts, script_callbacks, shared, sd_hijack
+import yaml
+import time
+import threading
+
+# Webui root path
+FILE_DIR = Path().absolute()
+
+# The extension base path
+EXT_PATH = FILE_DIR.joinpath('extensions')
+
+# Tags base path
+TAGS_PATH = Path(scripts.basedir()).joinpath('tags')
+
+# The path to the folder containing the wildcards and embeddings
+WILDCARD_PATH = FILE_DIR.joinpath('scripts/wildcards')
+EMB_PATH = Path(shared.cmd_opts.embeddings_dir)
+HYP_PATH = Path(shared.cmd_opts.hypernetwork_dir)
+
+try:
+    LORA_PATH = Path(shared.cmd_opts.lora_dir)
+except AttributeError:
+    LORA_PATH = None
+
+def find_ext_wildcard_paths():
+    """Returns the path to the extension wildcards folder"""
+    found = list(EXT_PATH.glob('*/wildcards/'))
+    return found
+
+
+# The path to the extension wildcards folder
+WILDCARD_EXT_PATHS = find_ext_wildcard_paths()
+
+# The path to the temporary files
+STATIC_TEMP_PATH = FILE_DIR.joinpath('tmp') # In the webui root, on windows it exists by default, on linux it doesn't
+TEMP_PATH = TAGS_PATH.joinpath('temp') # Extension specific temp files
+
+
+def get_wildcards():
+    """Returns a list of all wildcards. Works on nested folders."""
+    wildcard_files = list(WILDCARD_PATH.rglob("*.txt"))
+    resolved = [w.relative_to(WILDCARD_PATH).as_posix(
+    ) for w in wildcard_files if w.name != "put wildcards here.txt"]
+    return resolved
+
+
+def get_ext_wildcards():
+    """Returns a list of all extension wildcards. Works on nested folders."""
+    wildcard_files = []
+
+    for path in WILDCARD_EXT_PATHS:
+        wildcard_files.append(path.relative_to(FILE_DIR).as_posix())
+        wildcard_files.extend(p.relative_to(path).as_posix() for p in path.rglob("*.txt") if p.name != "put wildcards here.txt")
+        wildcard_files.append("-----")
+
+    return wildcard_files
+
+
+def get_ext_wildcard_tags():
+    """Returns a list of all tags found in extension YAML files found under a Tags: key."""
+    wildcard_tags = {} # { tag: count }
+    yaml_files = []
+    for path in WILDCARD_EXT_PATHS:
+        yaml_files.extend(p for p in path.rglob("*.yml"))
+        yaml_files.extend(p for p in path.rglob("*.yaml"))
+    count = 0
+    for path in yaml_files:
+        try:
+            with open(path, encoding="utf8") as file:
+                data = yaml.safe_load(file)
+                for item in data:
+                    if data[item] and 'Tags' in data[item]:
+                        wildcard_tags[count] = ','.join(data[item]['Tags'])
+                        count += 1
+                    else:
+                        print('Issue with tags found in ' + path.name + ' at item ' + item)
+        except yaml.YAMLError as exc:
+            print(exc)
+    # Sort by count
+    sorted_tags = sorted(wildcard_tags.items(), key=lambda item: item[1], reverse=True)
+    output = []
+    for tag, count in sorted_tags:
+        output.append(f"{tag},{count}")
+    return output
+
+
+def get_embeddings(sd_model):
+    """Write a list of all embeddings with their version"""
+
+    # Version constants
+    V1_SHAPE = 768
+    V2_SHAPE = 1024
+    emb_v1 = []
+    emb_v2 = []
+    results = []
+
+    try:
+        # Get embedding dict from sd_hijack to separate v1/v2 embeddings
+        emb_type_a = sd_hijack.model_hijack.embedding_db.word_embeddings
+        emb_type_b = sd_hijack.model_hijack.embedding_db.skipped_embeddings
+        # Get the shape of the first item in the dict
+        emb_a_shape = -1
+        emb_b_shape = -1
+        if (len(emb_type_a) > 0):
+            emb_a_shape = next(iter(emb_type_a.items()))[1].shape
+        if (len(emb_type_b) > 0):
+            emb_b_shape = next(iter(emb_type_b.items()))[1].shape
+
+        # Add embeddings to the correct list
+        if (emb_a_shape == V1_SHAPE):
+            emb_v1 = list(emb_type_a.keys())
+        elif (emb_a_shape == V2_SHAPE):
+            emb_v2 = list(emb_type_a.keys())
+
+        if (emb_b_shape == V1_SHAPE):
+            emb_v1 = list(emb_type_b.keys())
+        elif (emb_b_shape == V2_SHAPE):
+            emb_v2 = list(emb_type_b.keys())
+
+        # Get shape of current model
+        #vec = sd_model.cond_stage_model.encode_embedding_init_text(",", 1)
+        #model_shape = vec.shape[1]
+        # Show relevant entries at the top
+        #if (model_shape == V1_SHAPE):
+        #    results = [e + ",v1" for e in emb_v1] + [e + ",v2" for e in emb_v2]
+        #elif (model_shape == V2_SHAPE):
+        #    results = [e + ",v2" for e in emb_v2] + [e + ",v1" for e in emb_v1]
+        #else:
+        #    raise AttributeError # Fallback to old method
+        results = sorted([e + ",v1" for e in emb_v1] + [e + ",v2" for e in emb_v2], key=lambda x: x.lower())
+    except AttributeError:
+        print("tag_autocomplete_helper: Old webui version or unrecognized model shape, using fallback for embedding completion.")
+        # Get a list of all embeddings in the folder
+        all_embeds = [str(e.relative_to(EMB_PATH)) for e in EMB_PATH.rglob("*") if e.suffix in {".bin", ".pt", ".png",'.webp', '.jxl', '.avif'}]
+        # Remove files with a size of 0
+        all_embeds = [e for e in all_embeds if EMB_PATH.joinpath(e).stat().st_size > 0]
+        # Remove file extensions
+        all_embeds = [e[:e.rfind('.')] for e in all_embeds]
+        results = [e + "," for e in all_embeds]
+
+    write_to_temp_file('emb.txt', results)
+
+def get_hypernetworks():
+    """Write a list of all hypernetworks"""
+
+    # Get a list of all hypernetworks in the folder
+    all_hypernetworks = [str(h.name) for h in HYP_PATH.rglob("*") if h.suffix in {".pt"}]
+    # Remove file extensions
+    return sorted([h[:h.rfind('.')] for h in all_hypernetworks], key=lambda x: x.lower())
+
+def get_lora():
+    """Write a list of all lora"""
+
+    # Get a list of all lora in the folder
+    all_lora = [str(l.name) for l in LORA_PATH.rglob("*") if l.suffix in {".safetensors", ".ckpt", ".pt"}]
+    # Remove file extensions
+    return sorted([l[:l.rfind('.')] for l in all_lora], key=lambda x: x.lower())
+
+
+def write_tag_base_path():
+    """Writes the tag base path to a fixed location temporary file"""
+    with open(STATIC_TEMP_PATH.joinpath('tagAutocompletePath.txt'), 'w', encoding="utf-8") as f:
+        f.write(TAGS_PATH.relative_to(FILE_DIR).as_posix())
+
+
+def write_to_temp_file(name, data):
+    """Writes the given data to a temporary file"""
+    with open(TEMP_PATH.joinpath(name), 'w', encoding="utf-8") as f:
+        f.write(('\n'.join(data)))
+
+
+csv_files = []
+csv_files_withnone = []
+def update_tag_files():
+    """Returns a list of all potential tag files"""
+    global csv_files, csv_files_withnone
+    files = [str(t.relative_to(TAGS_PATH)) for t in TAGS_PATH.glob("*.csv")]
+    csv_files = files
+    csv_files_withnone = ["None"] + files
+
+
+
+# Write the tag base path to a fixed location temporary file
+# to enable the javascript side to find our files regardless of extension folder name
+if not STATIC_TEMP_PATH.exists():
+    STATIC_TEMP_PATH.mkdir(exist_ok=True)
+
+write_tag_base_path()
+update_tag_files()
+
+# Check if the temp path exists and create it if not
+if not TEMP_PATH.exists():
+    TEMP_PATH.mkdir(parents=True, exist_ok=True)
+
+# Set up files to ensure the script doesn't fail to load them
+# even if no wildcards or embeddings are found
+write_to_temp_file('wc.txt', [])
+write_to_temp_file('wce.txt', [])
+write_to_temp_file('wcet.txt', [])
+write_to_temp_file('hyp.txt', [])
+write_to_temp_file('lora.txt', [])
+# Only reload embeddings if the file doesn't exist, since they are already re-written on model load
+if not TEMP_PATH.joinpath("emb.txt").exists():
+    write_to_temp_file('emb.txt', [])
+
+# Write wildcards to wc.txt if found
+if WILDCARD_PATH.exists():
+    wildcards = [WILDCARD_PATH.relative_to(FILE_DIR).as_posix()] + get_wildcards()
+    if wildcards:
+        write_to_temp_file('wc.txt', wildcards)
+
+# Write extension wildcards to wce.txt if found
+if WILDCARD_EXT_PATHS is not None:
+    wildcards_ext = get_ext_wildcards()
+    if wildcards_ext:
+        write_to_temp_file('wce.txt', wildcards_ext)
+    # Write yaml extension wildcards to wcet.txt if found
+    wildcards_yaml_ext = get_ext_wildcard_tags()
+    if wildcards_yaml_ext:
+        write_to_temp_file('wcet.txt', wildcards_yaml_ext)
+
+# Write embeddings to emb.txt if found
+if EMB_PATH.exists():
+    # Get embeddings after the model loaded callback
+    script_callbacks.on_model_loaded(get_embeddings)
+
+if HYP_PATH.exists():
+    hypernets = get_hypernetworks()
+    if hypernets:
+        write_to_temp_file('hyp.txt', hypernets)
+
+if LORA_PATH is not None and LORA_PATH.exists():
+    lora = get_lora()
+    if lora:
+        write_to_temp_file('lora.txt', lora)
+
+# Register autocomplete options
+def on_ui_settings():
+    TAC_SECTION = ("tac", "Tag Autocomplete")
+    # Main tag file
+    shared.opts.add_option("tac_tagFile", shared.OptionInfo("zh_cn.csv", "Tag filename", gr.Dropdown, lambda: {"choices": csv_files_withnone}, refresh=update_tag_files, section=TAC_SECTION))
+    # Active in settings
+    shared.opts.add_option("tac_active", shared.OptionInfo(True, "Enable Tag Autocompletion", section=TAC_SECTION))
+    shared.opts.add_option("tac_activeIn.txt2img", shared.OptionInfo(True, "Active in txt2img (Requires restart)", section=TAC_SECTION))
+    shared.opts.add_option("tac_activeIn.img2img", shared.OptionInfo(True, "Active in img2img (Requires restart)", section=TAC_SECTION))
+    shared.opts.add_option("tac_activeIn.negativePrompts", shared.OptionInfo(True, "Active in negative prompts (Requires restart)", section=TAC_SECTION))
+    shared.opts.add_option("tac_activeIn.thirdParty", shared.OptionInfo(True, "Active in third party textboxes [Dataset Tag Editor] (Requires restart)", section=TAC_SECTION))
+    shared.opts.add_option("tac_activeIn.modelList", shared.OptionInfo("", "List of model names (with file extension) or their hashes to use as black/whitelist, separated by commas.", section=TAC_SECTION))
+    shared.opts.add_option("tac_activeIn.modelListMode", shared.OptionInfo("Blacklist", "Mode to use for model list", gr.Dropdown, lambda: {"choices": ["Blacklist","Whitelist"]}, section=TAC_SECTION))
+    # Results related settings
+    shared.opts.add_option("tac_maxResults", shared.OptionInfo(5, "Maximum results", section=TAC_SECTION))
+    shared.opts.add_option("tac_showAllResults", shared.OptionInfo(True, "Show all results", section=TAC_SECTION))
+    shared.opts.add_option("tac_resultStepLength", shared.OptionInfo(100, "How many results to load at once", section=TAC_SECTION))
+    shared.opts.add_option("tac_delayTime", shared.OptionInfo(100, "Time in ms to wait before triggering completion again (Requires restart)", section=TAC_SECTION))
+    shared.opts.add_option("tac_useWildcards", shared.OptionInfo(True, "Search for wildcards", section=TAC_SECTION))
+    shared.opts.add_option("tac_useEmbeddings", shared.OptionInfo(True, "Search for embeddings", section=TAC_SECTION))
+    shared.opts.add_option("tac_useHypernetworks", shared.OptionInfo(True, "Search for hypernetworks", section=TAC_SECTION))
+    shared.opts.add_option("tac_useLoras", shared.OptionInfo(True, "Search for Loras", section=TAC_SECTION))
+    shared.opts.add_option("tac_showWikiLinks", shared.OptionInfo(False, "Show '?' next to tags, linking to its Danbooru or e621 wiki page (Warning: This is an external site and very likely contains NSFW examples!)", section=TAC_SECTION))
+    # Insertion related settings
+    shared.opts.add_option("tac_replaceUnderscores", shared.OptionInfo(True, "Replace underscores with spaces on insertion", section=TAC_SECTION))
+    shared.opts.add_option("tac_escapeParentheses", shared.OptionInfo(True, "Escape parentheses on insertion", section=TAC_SECTION))
+    shared.opts.add_option("tac_appendComma", shared.OptionInfo(True, "Append comma on tag autocompletion", section=TAC_SECTION))
+    # Alias settings
+    shared.opts.add_option("tac_alias.searchByAlias", shared.OptionInfo(True, "Search by alias", section=TAC_SECTION))
+    shared.opts.add_option("tac_alias.onlyShowAlias", shared.OptionInfo(False, "Only show alias", section=TAC_SECTION))
+    # Translation settings
+    shared.opts.add_option("tac_translation.translationFile", shared.OptionInfo("zh_cn_tr.csv", "Translation filename", gr.Dropdown, lambda: {"choices": csv_files_withnone}, refresh=update_tag_files, section=TAC_SECTION))
+    shared.opts.add_option("tac_translation.oldFormat", shared.OptionInfo(False, "Translation file uses old 3-column translation format instead of the new 2-column one", section=TAC_SECTION))
+    shared.opts.add_option("tac_translation.searchByTranslation", shared.OptionInfo(True, "Search by translation", section=TAC_SECTION))
+    # Extra file settings
+    shared.opts.add_option("tac_extra.extraFile", shared.OptionInfo("None", "Extra filename (for small sets of custom tags)", gr.Dropdown, lambda: {"choices": csv_files_withnone}, refresh=update_tag_files, section=TAC_SECTION))
+    shared.opts.add_option("tac_extra.addMode", shared.OptionInfo("Insert before", "Mode to add the extra tags to the main tag list", gr.Dropdown, lambda: {"choices": ["Insert before","Insert after"]}, section=TAC_SECTION))
+
+script_callbacks.on_ui_settings(on_ui_settings)

a1111-sd-webui-tagcomplete/tags/colors.json

@@ -0,0 +1,7 @@
+{
+	"zh_cn": {
+		"1": ["lightblue", "dodgerblue"],
+		"2": ["violet", "darkorchid"],
+		"3": ["lightgreen", "darkgreen"]
+	}
+}

a1111-sd-webui-tagcomplete/tags/keymap.json

@@ -0,0 +1,13 @@
+{
+    "Usage": "For possible values, see https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_key_values. To disable a keybinding, leave it empty or set it to 'None'.",
+
+    "MoveUp": "ArrowUp",
+    "MoveDown": "ArrowDown",
+    "JumpUp": "PageUp",
+    "JumpDown": "PageDown",
+    "JumpToStart": "Home",
+    "JumpToEnd": "End",
+    "ChooseSelected": "Enter",
+    "ChooseFirstOrSelected": "Tab",
+    "Close": "Escape"
+}