357da321 · permissionBRICK/SillyTavern

.eslintrc.cjs+23 -0 Viewed

         // These rules should eventually be enabled.
         'no-async-promise-executor': 'off',
         'no-inner-declarations': 'off',
+        'brace-style': 'off',
+        // Additional formatting rules based on codebase conventions
+        'array-bracket-spacing': ['error', 'never'],
+        'computed-property-spacing': ['error', 'never'],
+        'block-spacing': ['error', 'always'],
+        'keyword-spacing': ['error', { before: true, after: true }],
+        'space-before-blocks': ['error', 'always'],
+        'space-before-function-paren': ['error', { anonymous: 'always', named: 'never', asyncArrow: 'always' }],
+        'space-in-parens': ['error', 'never'],
+        'comma-spacing': ['error', { before: false, after: true }],
+        'key-spacing': ['error', { beforeColon: false, afterColon: true }],
+        'func-call-spacing': ['error', 'never'],
+        'no-multiple-empty-lines': ['error', { max: 2, maxEOF: 1, maxBOF: 0 }],
+        'padded-blocks': ['error', 'never'],
+        'no-whitespace-before-property': 'error',
+        'space-unary-ops': ['error', { words: true, nonwords: false }],
+        'arrow-spacing': ['error', { before: true, after: true }],
+        'template-curly-spacing': ['error', 'never'],
+        'rest-spread-spacing': ['error', 'never'],
+        'generator-star-spacing': ['error', { before: false, after: true }],
+        'yield-star-spacing': ['error', { before: false, after: true }],
+        'template-tag-spacing': ['error', 'never'],
+        'switch-colon-spacing': ['error', { after: true, before: false }],
     },
 };

public/script.js+2 -14 Viewed

  * @returns {JQuery<HTMLElement>} Rendered HTMLElement.
  */
 export function updateMessageElement(mes, { messageId = chat.length - 1, messageElement = messageTemplate.clone(), adjustMediaScroll = SCROLL_BEHAVIOR.NONE } = {}) {
     let avatarImg = getThumbnailUrl('persona', user_avatar);
     //for non-user messages

@@ -3709,9 +3708,9 @@ class StreamingProcessor {
3709	}	3708	}
3710		3709
3711	/**	3710	/**
3712	* @returns {Generator<{ text: string, swipes: string[], logprobs: import('./scripts/logprobs.js').TokenLogprobs, toolCalls: any[], state: any }, void, void>}	3711	* @returns {AsyncGenerator<{ text: string, swipes: string[], logprobs: import('./scripts/logprobs.js').TokenLogprobs, toolCalls: any[], state: any }, void, void>}
3713	*/	3712	*/
3714	*nullStreamingGeneration() {	3713	async* nullStreamingGeneration() {
3715	throw new Error('Generation function for streaming is not hooked up');	3714	throw new Error('Generation function for streaming is not hooked up');
3716	}	3715	}
3717		3716

         // Add quiet generation prompt at depth 0
         if (quiet_prompt && quiet_prompt.length) {
             // here name1 is forced for all quiet prompts..why?
             const name = name1;
             //checks if we are in instruct, if so, formats the chat as such, otherwise just adds the quiet prompt

         if (!isAborted && power_user.auto_swipe && generatedTextFiltered(getMessage)) {
             is_send_press = false;
             return await swipe(null, SWIPE_DIRECTION.RIGHT, { source: SWIPE_SOURCE.AUTO_SWIPE, repeated: true, forceMesId: chat.length - 1 });
+        }
         console.debug('/api/chats/save called by /Generate');

         !fromStreaming && await eventSource.emit(event_types.MESSAGE_RECEIVED, chat_id, type);
         addOneMessage(chat[chat_id], { type: 'swipe' });
         !fromStreaming && await eventSource.emit(event_types.CHARACTER_MESSAGE_RENDERED, chat_id, type);
     } else {
         console.debug('entering chat update routine for non-swipe post');
         const newMessage = {};

@@ -8247,7 +8243,6 @@ export async function getChatsFromFiles(data, isGroupChat) {
8247	currentChat.shift();	8243	currentChat.shift();
8248	}	8244	}
8249	chat_dict[file_name] = currentChat;	8245	chat_dict[file_name] = currentChat;
8250
8251	} catch (error) {	8246	} catch (error) {
8252	console.error(error);	8247	console.error(error);
8253	}	8248	}

             select_rm_info('char_create', avatarId, oldSelectedChar);
             crop_data = undefined;
         } catch (error) {
             console.error('Error creating character', error);
             toastr.error(t`Failed to create character`);

             duration: 0, //used to be 100 //Disabled on Cohee's request. https://github.com/SillyTavern/SillyTavern/pull/4610/files#r2408731744
             queue: false,
             progress: function (animation, progress, remainingMs) {
                 if (is_animation_scroll) chatElement.scrollTop(getMessageBottomHeight(thisMesDiv));
             },
             complete: function () {

      * @param {boolean} [skipSwipeOut=false]
      */
     async function animateSwipe(run_generate = false, skipSwipeOut = false) {
         if (!skipSwipeOut) {
             //Swipe out.
             await animateSwipeTransition(mesId, { xEnd: `${swipeRange}px`, duration: swipeDuration });

     //If the swipe is not being deleted.
     if (source != SWIPE_SOURCE.DELETE && source != SWIPE_SOURCE.BACK) {
         // Make sure ad-hoc changes to extras are saved before swiping away
         syncMesToSwipe(mesId);

@@ -10382,7 +10373,6 @@ export async function doNewChat({ deleteCurrentChat = false } = {}) {
10382	await createOrEditCharacter(new CustomEvent('newChat'));	10373	await createOrEditCharacter(new CustomEvent('newChat'));
10383	if (deleteCurrentChat) await delChat(chat_file_for_del + '.jsonl');	10374	if (deleteCurrentChat) await delChat(chat_file_for_del + '.jsonl');
10384	}	10375	}
10385
10386	}	10376	}
10387		10377
10388	/**	10378	/**

                 divchat.style.borderRadius = '';
                 divchat.style.backgroundColor = '';
             } else {
                 divchat.style.borderRadius = '10px'; // Adjust the value to control the roundness of the corners
                 divchat.style.backgroundColor = ''; // Set the background color to your preference

public/scripts/BulkEditOverlay.js+2 -2 Viewed

      * @param {number} characterId
      * @returns {Promise<void>}
      */
-    static persona = async (characterId) => void(await convertCharacterToPersona(characterId));
+    static persona = async (characterId) => void (await convertCharacterToPersona(characterId));
     /**
      * Delete one or more characters,

     handleContextMenuShow = (event) => {
         event.preventDefault();
-        const [x,y] = this.#getContextMenuPosition(event);
+        const [x, y] = this.#getContextMenuPosition(event);
         CharacterContextMenu.show(x, y);
         this.#contextMenuOpen = true;
     };

public/scripts/PromptManager.js+0 -2 Viewed

      * @returns {void}
      */
     addPrompt(prompt, identifier) {
         if (typeof prompt !== 'object' || prompt === null) throw new Error('Object is not a prompt');
         const newPrompt = {

             this.updatePromptByIdentifier(identifier, prompt);
             debouncedSaveServiceSettings().then(() => this.render());
         });
+    }
     /**

public/scripts/RossAscends-mods.js+0 -3 Viewed

  * @returns {string} - A human-readable string that represents the time spent generating characters.
  */
 export function humanizeGenTime(total_gen_time) {
     //convert time_spent to humanized format of "_ Hours, _ Minutes, _ Seconds" from milliseconds
     let time_spent = total_gen_time || 0;
     time_spent = Math.floor(time_spent / 1000);

@@ -1274,8 +1273,6 @@ export function initRossMods() {
1274	}	1273	}
1275		1274
1276		1275
1277
1278
1279	if (event.ctrlKey && /^[1-9]$/.test(event.key)) {	1276	if (event.ctrlKey && /^[1-9]$/.test(event.key)) {
1280	// This will eventually be to trigger quick replies	1277	// This will eventually be to trigger quick replies
1281	// event.preventDefault();	1278	// event.preventDefault();

public/scripts/autocomplete/AutoComplete.js+0 -5 Viewed

@@ -80,8 +80,6 @@ export class AutoComplete {
80	}	80	}
81		81
82		82
83
84
85	/**	83	/**
86	* @param {HTMLTextAreaElement\|HTMLInputElement} textarea The textarea to receive autocomplete.	84	* @param {HTMLTextAreaElement\|HTMLInputElement} textarea The textarea to receive autocomplete.
87	* @param {() => boolean} checkIfActivate Function should return true only if under the current conditions, autocomplete should display (e.g., for slash commands: autoComplete.text[0] == '/')	85	* @param {() => boolean} checkIfActivate Function should return true only if under the current conditions, autocomplete should display (e.g., for slash commands: autoComplete.text[0] == '/')

             });
         if (this.isForceHidden) {
             // hidden with escape
             return this.hide();

@@ -465,7 +462,6 @@ export class AutoComplete {
465	}	462	}
466		463
467		464
468
469	/**	465	/**
470	* Create updated DOM.	466	* Create updated DOM.
471	*/	467	*/

@@ -514,7 +510,6 @@ export class AutoComplete {
514	}	510	}
515		511
516		512
517
518	/**	513	/**
519	* Update position of DOM.	514	* Update position of DOM.
520	*/	515	*/

public/scripts/autocomplete/AutoCompleteFuzzyScore.js+0 -3 Viewed

 export class AutoCompleteFuzzyScore {
     /**@type {number}*/ start;
     /**@type {number}*/ longestConsecutive;

public/scripts/autocomplete/AutoCompleteNameResult.js+0 -1 Viewed

@@ -2,7 +2,6 @@ import { AutoCompleteNameResultBase } from './AutoCompleteNameResultBase.js';
2	import { AutoCompleteSecondaryNameResult } from './AutoCompleteSecondaryNameResult.js';	2	import { AutoCompleteSecondaryNameResult } from './AutoCompleteSecondaryNameResult.js';
3		3
4		4
5
6	export class AutoCompleteNameResult extends AutoCompleteNameResultBase {	5	export class AutoCompleteNameResult extends AutoCompleteNameResultBase {
7	/**	6	/**
8	*	7	*

public/scripts/autocomplete/AutoCompleteNameResultBase.js+2 -3 Viewed

 import { AutoCompleteOption } from './AutoCompleteOption.js';
 export class AutoCompleteNameResultBase {
     /**@type {string} */ name;
     /**@type {number} */ start;
     /**@type {AutoCompleteOption[]} */ optionList = [];
     /**@type {boolean} */ canBeQuoted = false;
-    /**@type {()=>string} */ makeNoMatchText = ()=>`No matches found for "${this.name}"`;
+    /**@type {()=>string} */ makeNoMatchText = () => `No matches found for "${this.name}"`;
-    /**@type {()=>string} */ makeNoOptionsText = ()=>'No options';
+    /**@type {()=>string} */ makeNoOptionsText = () => 'No options';
     /**

public/scripts/autocomplete/AutoCompleteOption.js+1 -2 Viewed

 import { AutoCompleteFuzzyScore } from './AutoCompleteFuzzyScore.js';
 export class AutoCompleteOption {
     /** @type {string} */ name;
     /** @type {string} */ typeIcon;

                     name.classList.add('name');
                     name.classList.add('monospace');
                     name.textContent = noSlash ? '' : '/';
-                    key.split('').forEach(char=>{
+                    key.split('').forEach(char => {
                         const span = document.createElement('span'); {
                             span.textContent = char;
                             name.append(span);

public/scripts/bulk-edit.js+1 -1 Viewed

     if (!atLeastOneSelected) {
         // If none was selected, trigger click on all to deselect all of them
-        for(const character of characters) {
+        for (const character of characters) {
             const checked = $(character).find('.bulk_select_checkbox:checked') ?? false;
             if (checked && character instanceof HTMLElement) {
                 characterGroupOverlay.toggleSingleCharacter(character);

public/scripts/cfg-scale.js+0 -1 Viewed

         setTimeout(function () {
             $('#cfgConfig').hide();
         }, animation_duration);
+    }
     //duplicate options menu close handler from script.js
     //because this listener takes priority

public/scripts/chat-backups.js+1 -1 Viewed

             const deleteButton = document.createElement('div');
             deleteButton.classList.add('right_menu_button', 'fa-solid', 'fa-trash');
             deleteButton.title = t`Delete backup`;
-            deleteButton.addEventListener('click',async () => {
+            deleteButton.addEventListener('click', async () => {
                 const isDeleted = await this.deleteBackup(backup.file_name);
                 if (isDeleted) {
                     listItem.remove();

public/scripts/data-maid.js+0 -1 Viewed

                 categoryElement.remove();
                 this.displayEmptyPlaceholder();
             });
         });
         categoryElement.querySelectorAll('.dataMaidItemDelete').forEach(button => {
             button.addEventListener('click', async () => {

public/scripts/extensions/assets/index.js+1 -2 Viewed

     updateCurrentAssets().then(async function () {
         fetch(url, { cache: 'no-cache' })
             .then(response => response.json())
-            .then(async function(json) {
+            .then(async function (json) {
                 availableAssets = {};
                 $('#assets_menu').empty();

public/scripts/extensions/expressions/index.js+1 -3 Viewed

                 });
                 if (apiResult.ok) {
                     const data = await apiResult.json();
                     expressionsList = data.labels;
                     return expressionsList;

@@ -1488,7 +1487,6 @@ function chooseSpriteForExpression(spriteFolderName, expression, { prevExpressio
1488	}	1487	}
1489		1488
1490	return spriteFile;	1489	return spriteFile;
1491
1492	}	1490	}
1493		1491
1494	/**	1492	/**

         name: 'expression-folder-override',
         aliases: ['spriteoverride', 'costume'],
         callback: setSpriteFolderCommand,
-        namedArgumentList:[
+        namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'name',
                 description: 'Character name to set a subfolder for. If not provided, the character who last sent a message will be used.',

public/scripts/extensions/gallery/index.js+0 -1 Viewed

         const items = await getGalleryItems(url);
         return JSON.stringify(items.map(it => it.src));
     } catch (err) {
         console.error(err);
+    }

public/scripts/extensions/quick-reply/api/QuickReplyApi.js+9 -15 Viewed

     /** @type {SettingsUi} */ settingsUi;
     constructor(/** @type {QuickReplySettings} */settings, /** @type {SettingsUi} */settingsUi) {
         this.settings = settings;
         this.settingsUi = settingsUi;
+    }
     /**
      * @param {QuickReply} qr
      * @returns {QuickReplySet}
      */
     getSetByQr(qr) {
-        return QuickReplySet.list.find(it=>it.qrList.includes(qr));
+        return QuickReplySet.list.find(it => it.qrList.includes(qr));
+    }
     /**

@@ -48,13 +44,11 @@ export class QuickReplyApi {
48	getQrByLabel(setName, label) {	44	getQrByLabel(setName, label) {
49	const set = this.getSetByName(setName);	45	const set = this.getSetByName(setName);
50	if (!set) return;	46	if (!set) return;
51	if (Number.isInteger(label)) return set.qrList.find(it=>it.id == label);	47	if (Number.isInteger(label)) return set.qrList.find(it => it.id == label);
52	return set.qrList.find(it=>it.label == label);	48	return set.qrList.find(it => it.label == label);
53	}	49	}
54		50
55		51
56
57
58	/**	52	/**
59	* Executes a quick reply by its index and returns the result.	53	* Executes a quick reply by its index and returns the result.
60	*	54	*

      */
     async executeQuickReplyByIndex(idx) {
         const qr = [...this.settings.config.setList, ...(this.settings.chatConfig?.setList ?? [])]
-            .map(it=>it.set.qrList)
+            .map(it => it.set.qrList)
             .flat()[idx]
+        ;
         if (qr) {

         if (oldSet) {
             QuickReplySet.list.splice(QuickReplySet.list.indexOf(oldSet), 1, set);
         } else {
-            const idx = QuickReplySet.list.findIndex(it=>it.name.localeCompare(name) == 1);
+            const idx = QuickReplySet.list.findIndex(it => it.name.localeCompare(name) == 1);
             if (idx > -1) {
                 QuickReplySet.list.splice(idx, 0, set);
             } else {

      * @returns array with the names of all quick reply sets
      */
     listSets() {
-        return QuickReplySet.list.map(it=>it.name);
+        return QuickReplySet.list.map(it => it.name);
+    }
     /**
      * Gets a list of all globally active quick reply sets.

      * @returns array with the names of all quick reply sets
      */
     listGlobalSets() {
-        return this.settings.config.setList.map(it=>it.set.name);
+        return this.settings.config.setList.map(it => it.set.name);
+    }
     /**
      * Gets a list of all quick reply sets activated by the current chat.

      * @returns array with the names of all quick reply sets
      */
     listChatSets() {
-        return this.settings.chatConfig?.setList?.flatMap(it=>it.set.name) ?? [];
+        return this.settings.chatConfig?.setList?.flatMap(it => it.set.name) ?? [];
+    }
     /**

@@ -490,7 +484,7 @@ export class QuickReplyApi {
490	if (!set) {	484	if (!set) {
491	throw new Error(`No quick reply set with name "${name}" found.`);	485	throw new Error(`No quick reply set with name "${name}" found.`);
492	}	486	}
493	return set.qrList.map(it=>it.label);	487	return set.qrList.map(it => it.label);
494	}	488	}
495		489
496	/**	490	/**

public/scripts/extensions/quick-reply/index.js+13 -17 Viewed

 export { debounceAsync };
 const _VERBOSE = true;
 export const debug = (...msg) => _VERBOSE ? console.debug('[QR2]', ...msg) : null;
 export const log = (...msg) => _VERBOSE ? console.log('[QR2]', ...msg) : null;

 export let quickReplyApi;
 const loadSets = async () => {
     const response = await fetch('/api/settings/get', {
         method: 'POST',

                 set.disableSend = set.quickActionEnabled ?? false;
                 set.placeBeforeInput = set.placeBeforeInputEnabled ?? false;
                 set.injectInput = set.AutoInputInject ?? false;
-                set.qrList = set.quickReplySlots.map((slot,idx)=>{
+                set.qrList = set.quickReplySlots.map((slot, idx) => {
                     const qr = {};
                     qr.id = idx + 1;
                     qr.label = slot.label ?? '';

                     qr.executeOnNewChat = slot.autoExecute_newChat ?? false;
                     qr.executeBeforeGeneration = slot.autoExecute_beforeGeneration ?? false;
                     qr.automationId = slot.automationId ?? '';
-                    qr.contextList = (slot.contextMenu ?? []).map(it=>({
+                    qr.contextList = (slot.contextMenu ?? []).map(it => ({
                         set: it.preset,
                         isChained: it.chain,
                     }));

@@ -99,8 +95,8 @@ const loadSets = async () => {
99	}	95	}
100	}	96	}
101	// need to load QR lists after all sets are loaded to be able to resolve context menu entries	97	// need to load QR lists after all sets are loaded to be able to resolve context menu entries
102	setList.forEach((set, idx)=>{	98	setList.forEach((set, idx) => {
103	QuickReplySet.list[idx].qrList = set.qrList.map(it=>QuickReply.from(it));	99	QuickReplySet.list[idx].qrList = set.qrList.map(it => QuickReply.from(it));
104	QuickReplySet.list[idx].init();	100	QuickReplySet.list[idx].init();
105	});	101	});
106	log('sets: ', QuickReplySet.list);	102	log('sets: ', QuickReplySet.list);

         await functionToCall(...args);
     } else {
         log('queueing', { functionToCall, args });
-        executeQueue.push(async()=>await functionToCall(...args));
+        executeQueue.push(async () => await functionToCall(...args));
+    }
 };

     buttons = new ButtonUi(settings);
     buttons.show();
-    settings.onSave = ()=>buttons.refresh();
+    settings.onSave = () => buttons.refresh();
-    globalThis.executeQuickReplyByName = async(name, args = {}, options = {}) => {
+    globalThis.executeQuickReplyByName = async (name, args = {}, options = {}) => {
         let qr = [
             ...settings.config.setList,
             ...(settings.chatConfig?.setList ?? []),

@@ -193,14 +189,14 @@ const init = async () => {
193	]	189	]
194	.map(it => it.set.qrList)	190	.map(it => it.set.qrList)
195	.flat()	191	.flat()
196	.find(it=>it.label == name)	192	.find(it => it.label == name)
197	;	193	;
198	if (!qr) {	194	if (!qr) {
199	let [setName, ...qrName] = name.split('.');	195	let [setName, ...qrName] = name.split('.');
200	qrName = qrName.join('.');	196	qrName = qrName.join('.');
201	let qrs = QuickReplySet.get(setName);	197	let qrs = QuickReplySet.get(setName);
202	if (qrs) {	198	if (qrs) {
203	qr = qrs.qrList.find(it=>it.label == qrName);	199	qr = qrs.qrList.find(it => it.label == qrName);
204	}	200	}
205	}	201	}
206	if (qr && qr.onExecute) {	202	if (qr && qr.onExecute) {

     slash.init();
     autoExec = new AutoExecuteHandler(settings);
-    eventSource.on(event_types.APP_READY, async()=>await finalizeInit());
+    eventSource.on(event_types.APP_READY, async () => await finalizeInit());
     globalThis.quickReplyApi = quickReplyApi;
 };

     await autoExec.handleChatChanged();
 };
-eventSource.on(event_types.CHAT_CHANGED, (...args)=>executeIfReadyElseQueue(onChatChanged, args));
+eventSource.on(event_types.CHAT_CHANGED, (...args) => executeIfReadyElseQueue(onChatChanged, args));
 eventSource.on(event_types.CHARACTER_DELETED, purgeCharacterQuickReplySets);
 eventSource.on(event_types.CHARACTER_RENAMED, updateCharacterQuickReplySets);
 const onUserMessage = async () => {
     await autoExec.handleUser();
 };
-eventSource.makeFirst(event_types.USER_MESSAGE_RENDERED, (...args)=>executeIfReadyElseQueue(onUserMessage, args));
+eventSource.makeFirst(event_types.USER_MESSAGE_RENDERED, (...args) => executeIfReadyElseQueue(onUserMessage, args));
 const onAiMessage = async (messageId) => {
     if (['...'].includes(chat[messageId]?.mes)) {

     await autoExec.handleAi();
 };
-eventSource.makeFirst(event_types.CHARACTER_MESSAGE_RENDERED, (...args)=>executeIfReadyElseQueue(onAiMessage, args));
+eventSource.makeFirst(event_types.CHARACTER_MESSAGE_RENDERED, (...args) => executeIfReadyElseQueue(onAiMessage, args));
 const onGroupMemberDraft = async () => {
     await autoExec.handleGroupMemberDraft();

public/scripts/extensions/quick-reply/src/AutoExecuteHandler.js+1 -5 Viewed

@@ -8,8 +8,6 @@ export class AutoExecuteHandler {
8	/** @type {Boolean[]}*/ preventAutoExecuteStack = [];	8	/** @type {Boolean[]}*/ preventAutoExecuteStack = [];
9		9
10		10
11
12
13	constructor(/** @type {QuickReplySettings} */settings) {	11	constructor(/** @type {QuickReplySettings} */settings) {
14	this.settings = settings;	12	this.settings = settings;
15	}	13	}

+    }
     async performAutoExecute(/** @type {QuickReply[]} */qrList) {
         for (const qr of qrList) {
             this.preventAutoExecuteStack.push(qr.preventAutoExecute);
             try {
-                await qr.execute({ isAutoExecute:true });
+                await qr.execute({ isAutoExecute: true });
             } catch (ex) {
                 warn(ex);
             } finally {

public/scripts/extensions/quick-reply/src/QuickReply.js+104 -114 Viewed

      * @param {{ id?: number; contextList?: any; }} props
      */
     static from(props) {
-        props.contextList = (props.contextList ?? []).map((/** @type {any} */ it)=>QuickReplyContextLink.from(it));
+        props.contextList = (props.contextList ?? []).map((/** @type {any} */ it) => QuickReplyContextLink.from(it));
         return Object.assign(new this(), props);
+    }
     /**@type {number}*/ id;
     /**@type {string}*/ icon;
     /**@type {string}*/ label = '';

@@ -89,8 +87,6 @@ export class QuickReply {
89	}	87	}
90		88
91		89
92
93
94	unrender() {	90	unrender() {
95	this.dom?.remove();	91	this.dom?.remove();
96	this.dom = null;	92	this.dom = null;

                         menu.show(evt);
+                    }
                 });
-                root.addEventListener('click', (evt)=>{
+                root.addEventListener('click', (evt) => {
                     if (evt.ctrlKey) {
                         this.showEditor();
                         return;

@@ -169,8 +165,6 @@ export class QuickReply {
169	}	165	}
170		166
171		167
172
173
174	renderSettings(idx) {	168	renderSettings(idx) {
175	if (!this.settingsDom) {	169	if (!this.settingsDom) {
176	const item = document.createElement('div'); {	170	const item = document.createElement('div'); {

                             addNew.classList.add('fa-solid');
                             addNew.classList.add('fa-plus');
                             addNew.title = 'Add quick reply';
-                            addNew.addEventListener('click', ()=>this.onInsertBefore());
+                            addNew.addEventListener('click', () => this.onInsertBefore());
                             actions.append(addNew);
+                        }
                         const paste = document.createElement('div'); {

                             paste.classList.add('fa-solid');
                             paste.classList.add('fa-paste');
                             paste.title = 'Add quick reply from clipboard';
-                            paste.addEventListener('click', async()=>{
+                            paste.addEventListener('click', async () => {
                                 const text = await navigator.clipboard.readText();
                                 this.onInsertBefore(text);
                             });

                             importFile.classList.add('fa-solid');
                             importFile.classList.add('fa-file-import');
                             importFile.title = 'Add quick reply from JSON file';
-                            importFile.addEventListener('click', async()=>{
+                            importFile.addEventListener('click', async () => {
                                 const inp = document.createElement('input'); {
                                     inp.type = 'file';
                                     inp.accept = '.json';
-                                    inp.addEventListener('change', async()=>{
+                                    inp.addEventListener('change', async () => {
                                         if (inp.files.length > 0) {
                                             for (const file of inp.files) {
                                                 const text = await file.text();

                                 icon.classList.add('fa-solid');
                                 icon.classList.add(this.icon);
+                            }
-                            icon.addEventListener('click', async()=>{
+                            icon.addEventListener('click', async () => {
                                 let value = await showFontAwesomePicker();
                                 this.updateIcon(value);
                             });

                             lbl.classList.add('qr--set-itemLabel');
                             lbl.classList.add('text_pole');
                             lbl.value = this.label;
-                            lbl.addEventListener('input', ()=>this.updateLabel(lbl.value));
+                            lbl.addEventListener('input', () => this.updateLabel(lbl.value));
                             lblContainer.append(lbl);
+                        }
                         itemContent.append(lblContainer);

                         opt.classList.add('fa-solid');
                         opt.textContent = '⁝';
                         opt.title = 'Additional options:\n - large editor\n - context menu\n - auto-execution\n - tooltip';
-                        opt.addEventListener('click', ()=>this.showEditor());
+                        opt.addEventListener('click', () => this.showEditor());
                         optContainer.append(opt);
+                    }
                     itemContent.append(optContainer);

                     mes.classList.add('qr--set-itemMessage');
                     mes.value = this.message;
                     //HACK need to use jQuery to catch the triggered event from the expanded editor
-                    $(mes).on('input', ()=>this.updateMessage(mes.value));
+                    $(mes).on('input', () => this.updateMessage(mes.value));
                     itemContent.append(mes);
+                }
                 const actions = document.createElement('div'); {

                         move.classList.add('fa-solid');
                         move.classList.add('fa-truck-arrow-right');
                         move.title = 'Move quick reply to other set';
-                        move.addEventListener('click', ()=>this.onTransfer(this));
+                        move.addEventListener('click', () => this.onTransfer(this));
                         actions.append(move);
+                    }
                     const copy = document.createElement('div'); {

                         copy.classList.add('fa-solid');
                         copy.classList.add('fa-copy');
                         copy.title = 'Copy quick reply to clipboard';
-                        copy.addEventListener('click', async()=>{
+                        copy.addEventListener('click', async () => {
                             await navigator.clipboard.writeText(JSON.stringify(this));
                             copy.classList.add('qr--success');
                             await delay(3010);

                         cut.classList.add('fa-solid');
                         cut.classList.add('fa-cut');
                         cut.title = 'Cut quick reply to clipboard (copy and remove)';
-                        cut.addEventListener('click', async()=>{
+                        cut.addEventListener('click', async () => {
                             await navigator.clipboard.writeText(JSON.stringify(this));
                             this.delete();
                         });

                         exp.classList.add('fa-solid');
                         exp.classList.add('fa-file-export');
                         exp.title = 'Export quick reply as file';
-                        exp.addEventListener('click', ()=>{
+                        exp.addEventListener('click', () => {
-                            const blob = new Blob([JSON.stringify(this)], { type:'text' });
+                            const blob = new Blob([JSON.stringify(this)], { type: 'text' });
                             const url = URL.createObjectURL(blob);
                             const a = document.createElement('a'); {
                                 a.href = url;

                         del.classList.add('fa-trash-can');
                         del.classList.add('redWarningBG');
                         del.title = 'Remove Quick Reply\n---\nShift+Click to skip confirmation';
-                        del.addEventListener('click', async(evt)=>{
+                        del.addEventListener('click', async (evt) => {
                             if (!evt.shiftKey) {
                                 const result = await Popup.show.confirm(
                                     'Remove Quick Reply',

             else {
                 icon.textContent = '…';
+            }
-            icon.addEventListener('click', async()=>{
+            icon.addEventListener('click', async () => {
                 let value = await showFontAwesomePicker();
                 if (value === null) return;
                 if (this.icon) icon.classList.remove(this.icon);

             /**@type {HTMLInputElement}*/
             const showLabel = dom.querySelector('#qr--modal-showLabel');
             showLabel.checked = this.showLabel;
-            showLabel.addEventListener('click', ()=>{
+            showLabel.addEventListener('click', () => {
                 this.updateShowLabel(showLabel.checked);
             });
             /**@type {HTMLInputElement}*/
             const label = dom.querySelector('#qr--modal-label');
             label.value = this.label;
-            label.addEventListener('input', ()=>{
+            label.addEventListener('input', () => {
                 this.updateLabel(label.value);
             });
             let switcherList;
             // @ts-ignore
-            dom.querySelector('#qr--modal-switcher').addEventListener('click', (evt)=>{
+            dom.querySelector('#qr--modal-switcher').addEventListener('click', (evt) => {
                 if (switcherList) {
                     switcherList.remove();
                     switcherList = null;

                 const list = document.createElement('ul'); {
                     switcherList = list;
                     list.classList.add('qr--modal-switcherList');
-                    const makeList = (qrs)=>{
+                    const makeList = (qrs) => {
                         const setItem = document.createElement('li'); {
                             setItem.classList.add('qr--modal-switcherItem');
-                            setItem.addEventListener('click', ()=>{
+                            setItem.addEventListener('click', () => {
                                 list.innerHTML = '';
                                 for (const qrs of quickReplyApi.listSets()) {
                                     const item = document.createElement('li'); {
                                         item.classList.add('qr--modal-switcherItem');
-                                        item.addEventListener('click', ()=>{
+                                        item.addEventListener('click', () => {
                                             list.innerHTML = '';
                                             makeList(quickReplyApi.getSetByName(qrs));
                                         });

+                        }
                         const addItem = document.createElement('li'); {
                             addItem.classList.add('qr--modal-switcherItem');
-                            addItem.addEventListener('click', ()=>{
+                            addItem.addEventListener('click', () => {
                                 const qr = quickReplyApi.getSetByQr(this).addQuickReply();
                                 this.editorPopup.completeAffirmative();
                                 qr.showEditor();

+                            }
                             list.append(addItem);
+                        }
-                        for (const qr of qrs.qrList.toSorted((a,b)=>a.label.toLowerCase().localeCompare(b.label.toLowerCase()))) {
+                        for (const qr of qrs.qrList.toSorted((a, b) => a.label.toLowerCase().localeCompare(b.label.toLowerCase()))) {
                             const item = document.createElement('li'); {
                                 item.classList.add('qr--modal-switcherItem');
                                 if (qr == this) item.classList.add('qr--current');
-                                else item.addEventListener('click', ()=>{
+                                else item.addEventListener('click', () => {
                                     this.editorPopup.completeAffirmative();
                                     qr.showEditor();
                                 });

                 });
             };
             const updateScrollDebounced = updateScroll;
-            const updateSyntaxEnabled = ()=>{
+            const updateSyntaxEnabled = () => {
                 if (syntax.checked) {
                     dom.querySelector('#qr--modal-messageHolder').classList.remove('qr--noSyntax');
                 } else {

             // @ts-ignore
             if (navigator.keyboard) {
                 // @ts-ignore
-                navigator.keyboard.getLayoutMap().then(it=>dom.querySelector('#qr--modal-commentKey').textContent = it.get('Backslash'));
+                navigator.keyboard.getLayoutMap().then(it => dom.querySelector('#qr--modal-commentKey').textContent = it.get('Backslash'));
             } else {
                 dom.querySelector('#qr--modal-commentKey').closest('small').remove();
+            }

             const message = dom.querySelector('#qr--modal-message');
             this.editorMessage = message;
             message.value = this.message;
-            const updateMessageDebounced = debounce((value)=>this.updateMessage(value), 10);
+            const updateMessageDebounced = debounce((value) => this.updateMessage(value), 10);
             message.addEventListener('input', () => {
                 updateMessageDebounced(message.value);
                 updateScrollDebounced();
-            }, { passive:true });
+            }, { passive: true });
-            const getLineStart = ()=>{
+            const getLineStart = () => {
                 const start = message.selectionStart;
                 let lineStart;
                 if (start == 0 || message.value[start - 1] == '\n') {

+                }
                 return lineStart;
             };
-            message.addEventListener('keydown', async(evt) => {
+            message.addEventListener('keydown', async (evt) => {
                 if (this.isExecuting) return;
                 if (evt.key == 'Tab' && !evt.shiftKey && !evt.ctrlKey && !evt.altKey) {
                     // increase indent

                         document.execCommand('insertText', false, `\t${affectedLines.join('\n\t')}`);
                         message.selectionStart = start + 1;
                         message.selectionEnd = end + affectedLines.length;
-                        message.dispatchEvent(new Event('input', { bubbles:true }));
+                        message.dispatchEvent(new Event('input', { bubbles: true }));
                     } else if (!(ac.isReplaceable && ac.isActive)) {
                         evt.stopImmediatePropagation();
                         evt.stopPropagation();
                         // document.execCommand is deprecated (and potentially buggy in some browsers) but the only way to retain undo-history
                         document.execCommand('insertText', false, '\t');
-                        message.dispatchEvent(new Event('input', { bubbles:true }));
+                        message.dispatchEvent(new Event('input', { bubbles: true }));
+                    }
                 } else if (evt.key == 'Tab' && evt.shiftKey && !evt.ctrlKey && !evt.altKey) {
                     // decrease indent

                     const lineStart = getLineStart();
                     message.selectionStart = lineStart;
                     const affectedLines = message.value.substring(lineStart, end).split('\n');
-                    const newText = affectedLines.map(it=>it.replace(/^\t/, '')).join('\n');
+                    const newText = affectedLines.map(it => it.replace(/^\t/, '')).join('\n');
                     const delta = affectedLines.join('\n').length - newText.length;
                     // document.execCommand is deprecated (and potentially buggy in some browsers) but the only way to retain undo-history
                     if (delta > 0) {

@@ -697,7 +691,7 @@ export class QuickReply {
697	}	691	}
698	message.selectionStart = start - (affectedLines[0].startsWith('\t') ? 1 : 0);	692	message.selectionStart = start - (affectedLines[0].startsWith('\t') ? 1 : 0);
699	message.selectionEnd = end - delta;	693	message.selectionEnd = end - delta;
700	message.dispatchEvent(new Event('input', { bubbles:true }));	694	message.dispatchEvent(new Event('input', { bubbles: true }));
701	} else {	695	} else {
702	message.selectionStart = start;	696	message.selectionStart = start;
703	}	697	}

                         document.execCommand('insertText', false, `\n${indent}`);
                         message.selectionStart = start + 1 + indent.length;
                         message.selectionEnd  = message.selectionStart;
-                        message.dispatchEvent(new Event('input', { bubbles:true }));
+                        message.dispatchEvent(new Event('input', { bubbles: true }));
+                    }
                 } else if (evt.key == 'Enter' && evt.ctrlKey && !evt.shiftKey && !evt.altKey) {
                     if (executeShortcut.checked) {

                     parser.parse(message.value, false);
                     const start = message.selectionStart;
                     const end = message.selectionEnd;
-                    const comment = parser.commandIndex.findLast(it=>it.name == '*' && (it.start <= start && it.end >= start || it.start <= end && it.end >= end));
+                    const comment = parser.commandIndex.findLast(it => it.name == '*' && (it.start <= start && it.end >= start || it.start <= end && it.end >= end));
                     if (comment) {
                         // uncomment
                         let content = message.value.slice(comment.start + 1, comment.end - 1);

                         message.selectionStart = start + 3;
                         message.selectionEnd = end + 3;
+                    }
-                    message.dispatchEvent(new Event('input', { bubbles:true }));
+                    message.dispatchEvent(new Event('input', { bubbles: true }));
+                }
             });
             const ac = await setSlashCommandAutoComplete(message, true);
-            message.addEventListener('wheel', (evt)=>{
+            message.addEventListener('wheel', (evt) => {
                 updateScrollDebounced(evt);
             });
             // @ts-ignore
-            message.addEventListener('scroll', (evt)=>{
+            message.addEventListener('scroll', (evt) => {
                 updateScrollDebounced();
             });
             let preBreakPointStart;

             /**
              * @param {SlashCommandBreakPoint} bp
              */
-            const removeBreakpoint = (bp)=>{
+            const removeBreakpoint = (bp) => {
                 // start at -1 because "/" is not included in start-end
                 let start = bp.start - 1;
                 // step left until forward slash "/"

                 message.selectionEnd = end;
                 // document.execCommand is deprecated (and potentially buggy in some browsers) but the only way to retain undo-history
                 document.execCommand('insertText', false, '');
-                message.dispatchEvent(new Event('input', { bubbles:true }));
+                message.dispatchEvent(new Event('input', { bubbles: true }));
                 let postStart = preBreakPointStart;
                 let postEnd = preBreakPointEnd;
                 // set caret back to where it was

                     // selection end was behind breakpoint: move back by length of removed string
                     postEnd = preBreakPointEnd - (end - start);
+                }
-                return { start:postStart, end:postEnd };
+                return { start: postStart, end: postEnd };
             };
             /**
              * @param {SlashCommandExecutor} cmd
              */
-            const addBreakpoint = (cmd)=>{
+            const addBreakpoint = (cmd) => {
                 // start at -1 because "/" is not included in start-end
                 let start = cmd.start - 1;
                 let indent = '';

                 message.selectionEnd = start;
                 // document.execCommand is deprecated (and potentially buggy in some browsers) but the only way to retain undo-history
                 document.execCommand('insertText', false, breakpointText);
-                message.dispatchEvent(new Event('input', { bubbles:true }));
+                message.dispatchEvent(new Event('input', { bubbles: true }));
                 return breakpointText.length;
             };
-            const toggleBreakpoint = ()=>{
+            const toggleBreakpoint = () => {
                 const idx = message.selectionStart;
                 let postStart = preBreakPointStart;
                 let postEnd = preBreakPointEnd;
                 const parser = new SlashCommandParser();
                 parser.parse(message.value, false);
-                const cmdIdx = parser.commandIndex.findLastIndex(it=>it.start <= idx);
+                const cmdIdx = parser.commandIndex.findLastIndex(it => it.start <= idx);
                 if (cmdIdx > -1) {
                     const cmd = parser.commandIndex[cmdIdx];
                     if (cmd instanceof SlashCommandBreakPoint) {

                     message.selectionEnd = postEnd;
+                }
             };
-            message.addEventListener('pointerdown', (evt)=>{
+            message.addEventListener('pointerdown', (evt) => {
                 if (!evt.ctrlKey || !evt.altKey) return;
                 preBreakPointStart = message.selectionStart;
                 preBreakPointEnd = message.selectionEnd;
             });
-            message.addEventListener('pointerup', async(evt)=>{
+            message.addEventListener('pointerup', async (evt) => {
                 if (!evt.ctrlKey || !evt.altKey || message.selectionStart != message.selectionEnd) return;
                 toggleBreakpoint();
             });

             });
             window.addEventListener('resize', resizeListener);
             updateSyntaxEnabled();
-            const updateSyntax = ()=>{
+            const updateSyntax = () => {
                 if (messageSyntaxInner && syntax.checked) {
                     morphdom(
                         messageSyntaxInner,
-                        `<div>${hljs.highlight(`${message.value}${message.value.slice(-1) == '\n' ? ' ' : ''}`, { language:'stscript', ignoreIllegals:true })?.value}</div>`,
+                        `<div>${hljs.highlight(`${message.value}${message.value.slice(-1) == '\n' ? ' ' : ''}`, { language: 'stscript', ignoreIllegals: true })?.value}</div>`,
                         { childrenOnly: true },
                     );
                     updateScrollDebounced();

             const fpsTime = 1000 / 30;
             let lastMessageValue = null;
             let wasSyntax = null;
-            const updateSyntaxLoop = ()=>{
+            const updateSyntaxLoop = () => {
                 const now = Date.now();
                 // fps limit
                 if (now - lastSyntaxUpdate < fpsTime) return requestAnimationFrame(updateSyntaxLoop);

                 updateSyntax();
                 requestAnimationFrame(updateSyntaxLoop);
             };
-            requestAnimationFrame(()=>updateSyntaxLoop());
+            requestAnimationFrame(() => updateSyntaxLoop());
             message.style.setProperty('text-shadow', 'none', 'important');
             updateWrap();
             updateTabSize();

             const tpl = dom.querySelector('#qr--ctxItem');
             const linkList = dom.querySelector('#qr--ctxEditor');
             const fillQrSetSelect = (/**@type {HTMLSelectElement}*/select, /**@type {QuickReplyContextLink}*/ link) => {
-                [{ name: 'Select a QR set' }, ...QuickReplySet.list.toSorted((a,b)=>a.name.toLowerCase().localeCompare(b.name.toLowerCase()))].forEach(qrs => {
+                [{ name: 'Select a QR set' }, ...QuickReplySet.list.toSorted((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()))].forEach(qrs => {
                     const opt = document.createElement('option'); {
                         opt.value = qrs.name;
                         opt.textContent = qrs.name;

                 addCtxItem(link, this.contextList.length - 1);
             });
             const onContextSort = () => {
-                this.contextList = Array.from(linkList.querySelectorAll('.qr--ctxItem')).map((it,idx) => {
+                this.contextList = Array.from(linkList.querySelectorAll('.qr--ctxItem')).map((it, idx) => {
                     const link = this.contextList[Number(it.getAttribute('data-order'))];
                     it.setAttribute('data-order', String(idx));
                     return link;

             /**@type {HTMLInputElement}*/
             const preventAutoExecute = dom.querySelector('#qr--preventAutoExecute');
             preventAutoExecute.checked = this.preventAutoExecute;
-            preventAutoExecute.addEventListener('click', ()=>{
+            preventAutoExecute.addEventListener('click', () => {
                 this.preventAutoExecute = preventAutoExecute.checked;
                 this.updateContext();
             });
             /**@type {HTMLInputElement}*/
             const isHidden = dom.querySelector('#qr--isHidden');
             isHidden.checked = this.isHidden;
-            isHidden.addEventListener('click', ()=>{
+            isHidden.addEventListener('click', () => {
                 this.isHidden = isHidden.checked;
                 this.updateContext();
             });
             /**@type {HTMLInputElement}*/
             const executeOnStartup = dom.querySelector('#qr--executeOnStartup');
             executeOnStartup.checked = this.executeOnStartup;
-            executeOnStartup.addEventListener('click', ()=>{
+            executeOnStartup.addEventListener('click', () => {
                 this.executeOnStartup = executeOnStartup.checked;
                 this.updateContext();
             });
             /**@type {HTMLInputElement}*/
             const executeOnUser = dom.querySelector('#qr--executeOnUser');
             executeOnUser.checked = this.executeOnUser;
-            executeOnUser.addEventListener('click', ()=>{
+            executeOnUser.addEventListener('click', () => {
                 this.executeOnUser = executeOnUser.checked;
                 this.updateContext();
             });
             /**@type {HTMLInputElement}*/
             const executeOnAi = dom.querySelector('#qr--executeOnAi');
             executeOnAi.checked = this.executeOnAi;
-            executeOnAi.addEventListener('click', ()=>{
+            executeOnAi.addEventListener('click', () => {
                 this.executeOnAi = executeOnAi.checked;
                 this.updateContext();
             });
             /**@type {HTMLInputElement}*/
             const executeOnChatChange = dom.querySelector('#qr--executeOnChatChange');
             executeOnChatChange.checked = this.executeOnChatChange;
-            executeOnChatChange.addEventListener('click', ()=>{
+            executeOnChatChange.addEventListener('click', () => {
                 this.executeOnChatChange = executeOnChatChange.checked;
                 this.updateContext();
             });
             /**@type {HTMLInputElement}*/
             const executeOnGroupMemberDraft = dom.querySelector('#qr--executeOnGroupMemberDraft');
             executeOnGroupMemberDraft.checked = this.executeOnGroupMemberDraft;
-            executeOnGroupMemberDraft.addEventListener('click', ()=>{
+            executeOnGroupMemberDraft.addEventListener('click', () => {
                 this.executeOnGroupMemberDraft = executeOnGroupMemberDraft.checked;
                 this.updateContext();
             });
             /**@type {HTMLInputElement}*/
             const executeBeforeGeneration = dom.querySelector('#qr--executeBeforeGeneration');
             executeBeforeGeneration.checked = this.executeBeforeGeneration;
-            executeBeforeGeneration.addEventListener('click', ()=>{
+            executeBeforeGeneration.addEventListener('click', () => {
                 this.executeBeforeGeneration = executeBeforeGeneration.checked;
                 this.updateContext();
             });
             /**@type {HTMLInputElement}*/
             const executeOnNewChat = dom.querySelector('#qr--executeOnNewChat');
             executeOnNewChat.checked = this.executeOnNewChat;
-            executeOnNewChat.addEventListener('click', ()=>{
+            executeOnNewChat.addEventListener('click', () => {
                 this.executeOnNewChat = executeOnNewChat.checked;
                 this.updateContext();
             });

             /**@type {HTMLElement}*/
             const executeBtn = dom.querySelector('#qr--modal-execute');
             this.editorExecuteBtn = executeBtn;
-            executeBtn.addEventListener('click', async()=>{
+            executeBtn.addEventListener('click', async () => {
                 await this.executeFromEditor();
             });
             /**@type {HTMLElement}*/
             const executeBtnPause = dom.querySelector('#qr--modal-pause');
             this.editorExecuteBtnPause = executeBtnPause;
-            executeBtnPause.addEventListener('click', async()=>{
+            executeBtnPause.addEventListener('click', async () => {
                 if (this.abortController) {
                     if (this.abortController.signal.paused) {
                         this.abortController.continue('Continue button clicked');

             /**@type {HTMLElement}*/
             const executeBtnStop = dom.querySelector('#qr--modal-stop');
             this.editorExecuteBtnStop = executeBtnStop;
-            executeBtnStop.addEventListener('click', async()=>{
+            executeBtnStop.addEventListener('click', async () => {
                 this.abortController?.abort('Stop button clicked');
             });

             const inputMirror = dom.querySelector('#qr--modal-send_textarea');
             // @ts-ignore
             inputMirror.value = inputOg.value;
-            const inputOgMo = new MutationObserver(muts=>{
+            const inputOgMo = new MutationObserver(muts => {
-                if (muts.find(it=>[...it.removedNodes].includes(inputMirror) || [...it.removedNodes].find(n=>n.contains(inputMirror)))) {
+                if (muts.find(it => [...it.removedNodes].includes(inputMirror) || [...it.removedNodes].find(n => n.contains(inputMirror)))) {
                     inputOg.removeEventListener('input', inputOgListener);
+                }
             });
-            inputOgMo.observe(document.body, { childList:true });
+            inputOgMo.observe(document.body, { childList: true });
-            const inputOgListener = ()=>{
+            const inputOgListener = () => {
                 // @ts-ignore
                 inputMirror.value = inputOg.value;
             };
             inputOg.addEventListener('input', inputOgListener);
-            inputMirror.addEventListener('input', ()=>{
+            inputMirror.addEventListener('input', () => {
                 // @ts-ignore
                 inputOg.value = inputMirror.value;
             });
             /**@type {HTMLElement}*/
             const resumeBtn = dom.querySelector('#qr--modal-resume');
-            resumeBtn.addEventListener('click', ()=>{
+            resumeBtn.addEventListener('click', () => {
                 this.debugController?.resume();
             });
             /**@type {HTMLElement}*/
             const stepBtn = dom.querySelector('#qr--modal-step');
-            stepBtn.addEventListener('click', ()=>{
+            stepBtn.addEventListener('click', () => {
                 this.debugController?.step();
             });
             /**@type {HTMLElement}*/
             const stepIntoBtn = dom.querySelector('#qr--modal-stepInto');
-            stepIntoBtn.addEventListener('click', ()=>{
+            stepIntoBtn.addEventListener('click', () => {
                 this.debugController?.stepInto();
             });
             /**@type {HTMLElement}*/
             const stepOutBtn = dom.querySelector('#qr--modal-stepOut');
-            stepOutBtn.addEventListener('click', ()=>{
+            stepOutBtn.addEventListener('click', () => {
                 this.debugController?.stepOut();
             });
             /**@type {HTMLElement}*/
             const minimizeBtn = dom.querySelector('#qr--modal-minimize');
-            minimizeBtn.addEventListener('click', ()=>{
+            minimizeBtn.addEventListener('click', () => {
                 this.editorDom.classList.add('qr--minimized');
             });
             const maximizeBtn = dom.querySelector('#qr--modal-maximize');
-            maximizeBtn.addEventListener('click', ()=>{
+            maximizeBtn.addEventListener('click', () => {
                 this.editorDom.classList.remove('qr--minimized');
             });
             /**@type {boolean}*/

             let wStart;
             /**@type {HTMLElement}*/
             const resizeHandle = dom.querySelector('#qr--resizeHandle');
-            resizeHandle.addEventListener('pointerdown', (evt)=>{
+            resizeHandle.addEventListener('pointerdown', (evt) => {
                 if (isResizing) return;
                 isResizing = true;
                 evt.preventDefault();
                 resizeStart = evt.x;
                 // @ts-ignore
                 wStart = dom.querySelector('#qr--qrOptions').offsetWidth;
-                const dragListener = debounce((evt)=>{
+                const dragListener = debounce((evt) => {
                     const w = wStart + resizeStart - evt.x;
                     // @ts-ignore
                     dom.querySelector('#qr--qrOptions').style.setProperty('--width', `${w}px`);
                 }, 5);
-                window.addEventListener('pointerup', ()=>{
+                window.addEventListener('pointerup', () => {
                     // @ts-ignore
                     window.removeEventListener('pointermove', dragListener);
                     isResizing = false;
-                }, { once:true });
+                }, { once: true });
                 // @ts-ignore
                 window.addEventListener('pointermove', dragListener);
             });

@@ -1221,13 +1215,13 @@ export class QuickReply {
1221	}	1215	}
1222	this.clone.style.position = 'fixed';	1216	this.clone.style.position = 'fixed';
1223	this.clone.style.visibility = 'hidden';	1217	this.clone.style.visibility = 'hidden';
1224	const mo = new MutationObserver(muts=>{	1218	const mo = new MutationObserver(muts => {
1225	if (muts.find(it=>[...it.removedNodes].includes(this.editorMessage) \|\| [...it.removedNodes].find(n=>n.contains(this.editorMessage)))) {	1219	if (muts.find(it => [...it.removedNodes].includes(this.editorMessage) \|\| [...it.removedNodes].find(n => n.contains(this.editorMessage)))) {
1226	this.clone?.remove();	1220	this.clone?.remove();
1227	this.clone = null;	1221	this.clone = null;
1228	}	1222	}
1229	});	1223	});
1230	mo.observe(document.body, { childList:true });	1224	mo.observe(document.body, { childList: true });
1231	}	1225	}
1232	document.body.append(this.clone);	1226	document.body.append(this.clone);
1233	this.clone.style.width = `${inputRect.width}px`;	1227	this.clone.style.width = `${inputRect.width}px`;

+    }
     async executeFromEditor() {
         if (this.isExecuting) return;
-        this.editorPopup.onClosing = ()=>false;
+        this.editorPopup.onClosing = () => false;
         const uuidCheck = /^[0-9a-z]{8}(-[0-9a-z]{4}){3}-[0-9a-z]{12}$/;
         const oText = this.message;
         this.isExecuting = true;

             });
         };
         const updateScrollDebounced = updateScroll;
-        syntax.addEventListener('wheel', (evt)=>{
+        syntax.addEventListener('wheel', (evt) => {
             updateScrollDebounced(evt);
         });
         // @ts-ignore
-        syntax.addEventListener('scroll', (evt)=>{
+        syntax.addEventListener('scroll', (evt) => {
             updateScrollDebounced();
         });
         try {
             this.abortController = new SlashCommandAbortController();
             this.debugController = new SlashCommandDebugController();
-            this.debugController.onBreakPoint = async(closure, executor)=>{
+            this.debugController.onBreakPoint = async (closure, executor) => {
                 this.editorDom.classList.add('qr--isPaused');
-                syntax.innerHTML = hljs.highlight(`${closure.fullText}${closure.fullText.slice(-1) == '\n' ? ' ' : ''}`, { language:'stscript', ignoreIllegals:true })?.value;
+                syntax.innerHTML = hljs.highlight(`${closure.fullText}${closure.fullText.slice(-1) == '\n' ? ' ' : ''}`, { language: 'stscript', ignoreIllegals: true })?.value;
                 this.editorMessageLabel.innerHTML = '';
                 if (uuidCheck.test(closure.source)) {
                     const p0 = document.createElement('span'); {

@@ -1318,7 +1312,7 @@ export class QuickReply {
1318	this.editorMessageLabel.append(p0);	1312	this.editorMessageLabel.append(p0);
1319	}	1313	}
1320	const p1 = document.createElement('strong'); {	1314	const p1 = document.createElement('strong'); {
1321	p1.textContent = executor.source.slice(0,5);	1315	p1.textContent = executor.source.slice(0, 5);
1322	this.editorMessageLabel.append(p1);	1316	this.editorMessageLabel.append(p1);
1323	}	1317	}
1324	const p2 = document.createElement('span'); {	1318	const p2 = document.createElement('span'); {

                 /**
                  * @param {SlashCommandScope} scope
                  */
-                const buildVars = (scope, isCurrent = false)=>{
+                const buildVars = (scope, isCurrent = false) => {
                     if (!isCurrent) {
                         ci--;
+                    }

@@ -1358,7 +1352,7 @@ export class QuickReply {
1358	}	1352	}
1359	wrap.append(namedTitle);	1353	wrap.append(namedTitle);
1360	}	1354	}
1361	const keys = new Set([...Object.keys(this.debugController.namedArguments ?? {}), ...(executor.namedArgumentList ?? []).map(it=>it.name)]);	1355	const keys = new Set([...Object.keys(this.debugController.namedArguments ?? {}), ...(executor.namedArgumentList ?? []).map(it => it.name)]);
1362	for (const key of keys) {	1356	for (const key of keys) {
1363	if (key[0] == '_') continue;	1357	if (key[0] == '_') continue;
1364	const item = document.createElement('div'); {	1358	const item = document.createElement('div'); {

                                         const vUnresolved = document.createElement('div'); {
                                             vUnresolved.classList.add('qr--val');
                                             vUnresolved.classList.add('qr--singleCol');
-                                            const val = executor.namedArgumentList.find(it=>it.name == key)?.value;
+                                            const val = executor.namedArgumentList.find(it => it.name == key)?.value;
                                             if (val instanceof SlashCommandClosure) {
                                                 vUnresolved.classList.add('qr--closure');
                                                 vUnresolved.title = val.rawText;

                                 // @ts-ignore
                                 while (unnamed.length < executor.unnamedArgumentList?.length ?? 0) unnamed.push(undefined);
                                 // @ts-ignore
-                                unnamed = unnamed.map((it,idx)=>[executor.unnamedArgumentList?.[idx], it]);
+                                unnamed = unnamed.map((it, idx) => [executor.unnamedArgumentList?.[idx], it]);
                                 // @ts-ignore
                                 for (const arg of unnamed) {
                                     i++;

                             title.textContent = isCurrent ? 'Current Scope' : 'Parent Scope';
                             if (c.source == source) {
                                 let hi;
-                                title.addEventListener('pointerenter', ()=>{
+                                title.addEventListener('pointerenter', () => {
                                     const loc = this.getEditorPosition(Math.max(0, c.executorList[0].start - 1), c.executorList.slice(-1)[0].end, c.fullText);
                                     const layer = syntax.getBoundingClientRect();
                                     hi = document.createElement('div');

@@ -1522,7 +1516,7 @@ export class QuickReply {
1522	hi.style.height = `${loc.bottom - loc.top}px`;	1516	hi.style.height = `${loc.bottom - loc.top}px`;
1523	syntax.append(hi);	1517	syntax.append(hi);
1524	});	1518	});
1525	title.addEventListener('pointerleave', ()=>hi?.remove());	1519	title.addEventListener('pointerleave', () => hi?.remove());
1526	}	1520	}
1527	wrap.append(title);	1521	wrap.append(title);
1528	}	1522	}

+                    }
                     return wrap;
                 };
-                const buildStack = ()=>{
+                const buildStack = () => {
                     const wrap = document.createElement('div'); {
                         wrap.classList.add('qr--stack');
                         const title = document.createElement('div'); {

                                 item.classList.add('qr--item');
                                 if (executor.source == source) {
                                     let hi;
-                                    item.addEventListener('pointerenter', ()=>{
+                                    item.addEventListener('pointerenter', () => {
                                         const loc = this.getEditorPosition(Math.max(0, executor.start - 1), executor.end, c.fullText);
                                         const layer = syntax.getBoundingClientRect();
                                         hi = document.createElement('div');

                                         hi.style.height = `${loc.bottom - loc.top}px`;
                                         syntax.append(hi);
                                     });
-                                    item.addEventListener('pointerleave', ()=>hi?.remove());
+                                    item.addEventListener('pointerleave', () => hi?.remove());
+                                }
                                 const cmd = document.createElement('div'); {
                                     cmd.classList.add('qr--cmd');

                                     if (uuidCheck.test(executor.source)) {
                                         const p1 = document.createElement('span'); {
                                             p1.classList.add('qr--fixed');
-                                            p1.textContent = executor.source.slice(0,5);
+                                            p1.textContent = executor.source.slice(0, 5);
                                             src.append(p1);
+                                        }
                                         const p2 = document.createElement('span'); {

         this.editorMessageLabel.innerHTML = '';
         this.editorMessageLabel.textContent = 'Message / Command: ';
         this.editorMessage.value = oText;
-        this.editorMessage.dispatchEvent(new Event('input', { bubbles:true }));
+        this.editorMessage.dispatchEvent(new Event('input', { bubbles: true }));
         this.editorExecutePromise = null;
         this.editorExecuteBtn.classList.remove('qr--busy');
         this.editorDom.classList.remove('qr--isExecuting');

@@ -1769,8 +1763,6 @@ export class QuickReply {
1769	}	1763	}
1770		1764
1771		1765
1772
1773
1774	delete() {	1766	delete() {
1775	if (this.onDelete) {	1767	if (this.onDelete) {
1776	this.unrender();	1768	this.unrender();

         this.updateContext();
+    }
     removeContextLink(setName) {
-        const idx = this.contextList.findIndex(it=>it.set.name == setName);
+        const idx = this.contextList.findIndex(it => it.set.name == setName);
         if (idx > -1) {
             this.contextList.splice(idx, 1);
             this.updateContext();

@@ -1908,8 +1900,6 @@ export class QuickReply {
1908	}	1900	}
1909		1901
1910		1902
1911
1912
1913	toJSON() {	1903	toJSON() {
1914	return {	1904	return {
1915	id: this.id,	1905	id: this.id,

public/scripts/extensions/quick-reply/src/QuickReplyConfig.js+12 -20 Viewed

     /**@type {HTMLElement}*/ setListDom;
     static from(props) {
-        props.setList = props.setList?.map(it=>QuickReplySetLink.from(it))?.filter(it=>it.set) ?? [];
+        props.setList = props.setList?.map(it => QuickReplySetLink.from(it))?.filter(it => it.set) ?? [];
         const instance = Object.assign(new this(), props);
         instance.init();
         return instance;
+    }
     init() {
-        this.setList.forEach(it=>this.hookQuickReplyLink(it));
+        this.setList.forEach(it => this.hookQuickReplyLink(it));
+    }
     hasSet(qrs) {
-        return this.setList.find(it=>it.set == qrs) != null;
+        return this.setList.find(it => it.set == qrs) != null;
+    }
     addSet(qrs, isVisible = true) {
         if (!this.hasSet(qrs)) {

@@ -45,7 +41,7 @@ export class QuickReplyConfig {
45	}	41	}
46	}	42	}
47	removeSet(qrs) {	43	removeSet(qrs) {
48	const idx = this.setList.findIndex(it=>it.set == qrs);	44	const idx = this.setList.findIndex(it => it.set == qrs);
49	if (idx > -1) {	45	if (idx > -1) {
50	this.setList.splice(idx, 1);	46	this.setList.splice(idx, 1);
51	this.update();	47	this.update();

+    }
     renderSettingsInto(/**@type {HTMLElement}*/root) {
         /**@type {HTMLElement}*/
         this.setListDom = root.querySelector('.qr--setList');
-        root.querySelector('.qr--setListAdd').addEventListener('click', ()=>{
+        root.querySelector('.qr--setListAdd').addEventListener('click', () => {
-            const newSet = QuickReplySet.list.find(qr=>!this.setList.find(qrl=>qrl.set == qr));
+            const newSet = QuickReplySet.list.find(qr => !this.setList.find(qrl => qrl.set == qr));
             if (newSet) {
                 this.addSet(newSet);
             } else {

         // @ts-ignore
         $(this.setListDom).sortable({
             delay: getSortableDelay(),
-            stop: ()=>this.onSetListSort(),
+            stop: () => this.onSetListSort(),
         });
-        this.setList.filter(it=>!it.set.isDeleted).forEach((qrl,idx)=>this.setListDom.append(qrl.renderSettings(idx)));
+        this.setList.filter(it => !it.set.isDeleted).forEach((qrl, idx) => this.setListDom.append(qrl.renderSettings(idx)));
+    }
     onSetListSort() {
-        this.setList = Array.from(this.setListDom.children).map((it,idx)=>{
+        this.setList = Array.from(this.setListDom.children).map((it, idx) => {
             const qrl = this.setList[Number(it.getAttribute('data-order'))];
             qrl.index = idx;
             it.setAttribute('data-order', String(idx));

+    }
     /**
      * @param {QuickReplySetLink} qrl
      */
     hookQuickReplyLink(qrl) {
-        qrl.onDelete = ()=>this.deleteQuickReplyLink(qrl);
+        qrl.onDelete = () => this.deleteQuickReplyLink(qrl);
-        qrl.onUpdate = ()=>this.update();
+        qrl.onUpdate = () => this.update();
-        qrl.onRequestEditSet = ()=>this.requestEditSet(qrl.set);
+        qrl.onRequestEditSet = () => this.requestEditSet(qrl.set);
+    }
     deleteQuickReplyLink(qrl) {

public/scripts/extensions/quick-reply/src/QuickReplyContextLink.js+0 -2 Viewed

@@ -8,8 +8,6 @@ export class QuickReplyContextLink {
8	}	8	}
9		9
10		10
11
12
13	/*@type {QuickReplySet}/ set;	11	/*@type {QuickReplySet}/ set;
14	/*@type {Boolean}/ isChained = false;	12	/*@type {Boolean}/ isChained = false;
15		13

public/scripts/extensions/quick-reply/src/QuickReplySet.js+25 -26 Viewed

      * @param {string} name - name of the QuickReplySet
      */
     static get(name) {
-        return this.list.find(it=>it.name == name);
+        return this.list.find(it => it.name == name);
+    }
     /**@type {string}*/ name;

@@ -42,11 +42,11 @@ export class QuickReplySet {
42	/*@type {HTMLElement}/ settingsDom;	42	/*@type {HTMLElement}/ settingsDom;
43		43
44	constructor() {	44	constructor() {
45	this.save = debounceAsync(()=>this.performSave(), 200);	45	this.save = debounceAsync(() => this.performSave(), 200);
46	}	46	}
47		47
48	init() {	48	init() {
49	this.qrList.forEach(qr=>this.hookQuickReply(qr));	49	this.qrList.forEach(qr => this.hookQuickReply(qr));
50	}	50	}
51		51
52	unrender() {	52	unrender() {

                 this.dom = root;
                 root.classList.add('qr--buttons');
                 this.updateColor();
-                this.qrList.filter(qr=>!qr.isHidden).forEach(qr=>{
+                this.qrList.filter(qr => !qr.isHidden).forEach(qr => {
                     root.append(qr.render());
                 });
+            }

     rerender() {
         if (!this.dom) return;
         this.dom.innerHTML = '';
-        this.qrList.filter(qr=>!qr.isHidden).forEach(qr=>{
+        this.qrList.filter(qr => !qr.isHidden).forEach(qr => {
             this.dom.append(qr.render());
         });
+    }

         if (!this.settingsDom) {
             this.settingsDom = document.createElement('div'); {
                 this.settingsDom.classList.add('qr--set-qrListContents');
-                this.qrList.forEach((qr,idx)=>{
+                this.qrList.forEach((qr, idx) => {
                     this.renderSettingsItem(qr, idx);
                 });
+            }

      */
     async executeWithOptions(qr, options = {}) {
         options = Object.assign({
-            message:null,
+            message: null,
-            isAutoExecute:false,
+            isAutoExecute: false,
-            isEditor:false,
+            isEditor: false,
-            isRun:false,
+            isRun: false,
-            scope:null,
+            scope: null,
-            executionOptions:{},
+            executionOptions: {},
         }, options);
         const execOptions = options.executionOptions;
         /**@type {HTMLTextAreaElement}*/

+    }
     addQuickReply(data = {}) {
-        const id = Math.max(this.idIndex, this.qrList.reduce((max,qr)=>Math.max(max,qr.id),0)) + 1;
+        const id = Math.max(this.idIndex, this.qrList.reduce((max, qr) => Math.max(max, qr.id), 0)) + 1;
-        data.id =
+        data.id = this.idIndex = id + 1;
-        this.idIndex = id + 1;
         const qr = QuickReply.from(data);
         this.qrList.push(qr);
         this.hookQuickReply(qr);

      */
     hookQuickReply(qr) {
         // @ts-ignore
-        qr.onDebug = ()=>this.debug(qr);
+        qr.onDebug = () => this.debug(qr);
-        qr.onExecute = (_, options)=>this.executeWithOptions(qr, options);
+        qr.onExecute = (_, options) => this.executeWithOptions(qr, options);
-        qr.onDelete = ()=>this.removeQuickReply(qr);
+        qr.onDelete = () => this.removeQuickReply(qr);
-        qr.onUpdate = ()=>this.save();
+        qr.onUpdate = () => this.save();
-        qr.onInsertBefore = (qrJson)=>{
+        qr.onInsertBefore = (qrJson) => {
             this.addQuickReplyFromText(qrJson);
             const newQr = this.qrList.pop();
             this.qrList.splice(this.qrList.indexOf(qr), 0, newQr);

+            }
             this.save();
         };
-        qr.onTransfer = async()=>{
+        qr.onTransfer = async () => {
             /**@type {HTMLSelectElement} */
             let sel;
             let isCopy = false;

@@ -301,14 +300,14 @@ export class QuickReplySet {
301	sel.append(opt);	300	sel.append(opt);
302	}	301	}
303	}	302	}
304	sel.addEventListener('keyup', (evt)=>{	303	sel.addEventListener('keyup', (evt) => {
305	if (evt.key == 'Shift') {	304	if (evt.key == 'Shift') {
306	// @ts-ignore	305	// @ts-ignore
307	(dlg.dom ?? dlg.dlg).classList.remove('qr--isCopy');	306	(dlg.dom ?? dlg.dlg).classList.remove('qr--isCopy');
308	return;	307	return;
309	}	308	}
310	});	309	});
311	sel.addEventListener('keydown', (evt)=>{	310	sel.addEventListener('keydown', (evt) => {
312	if (evt.key == 'Shift') {	311	if (evt.key == 'Shift') {
313	// @ts-ignore	312	// @ts-ignore
314	(dlg.dom ?? dlg.dlg).classList.add('qr--isCopy');	313	(dlg.dom ?? dlg.dlg).classList.add('qr--isCopy');

                     dom.append(hintP);
+                }
+            }
-            const dlg = new Popup(dom, POPUP_TYPE.CONFIRM, null, { okButton:'Transfer', cancelButton:'Cancel' });
+            const dlg = new Popup(dom, POPUP_TYPE.CONFIRM, null, { okButton: 'Transfer', cancelButton: 'Cancel' });
             const copyBtn = document.createElement('div'); {
                 copyBtn.classList.add('qr--copy');
                 copyBtn.classList.add('menu_button');
                 copyBtn.textContent = 'Copy';
-                copyBtn.addEventListener('click', ()=>{
+                copyBtn.addEventListener('click', () => {
                     isCopy = true;
                     dlg.completeAffirmative();
                 });

             sel.focus();
             await prom;
             if (dlg.result == POPUP_RESULT.AFFIRMATIVE) {
-                const qrs = QuickReplySet.list.find(it=>it.name == sel.value);
+                const qrs = QuickReplySet.list.find(it => it.name == sel.value);
                 qrs.addQuickReply(qr.toJSON());
                 if (!isCopy) {
                     qr.delete();

public/scripts/extensions/quick-reply/src/QuickReplySetLink.js+6 -14 Viewed

@@ -9,8 +9,6 @@ export class QuickReplySetLink {
9	}	9	}
10		10
11		11
12
13
14	/*@type {QuickReplySet}/ set;	12	/*@type {QuickReplySet}/ set;
15	/*@type {Boolean}/ isVisible = true;	13	/*@type {Boolean}/ isVisible = true;
16		14

     /**@type {HTMLElement}*/ settingsDom;
     renderSettings(idx) {
         this.index = idx;
         const item = document.createElement('div'); {

             const set = document.createElement('select'); {
                 set.classList.add('qr--set');
                 // fix for jQuery sortable breaking childrens' touch events
-                set.addEventListener('touchstart', (evt)=>evt.stopPropagation());
+                set.addEventListener('touchstart', (evt) => evt.stopPropagation());
-                set.addEventListener('change', ()=>{
+                set.addEventListener('change', () => {
                     this.set = QuickReplySet.get(set.value);
                     this.update();
                 });
-                QuickReplySet.list.toSorted((a,b)=>a.name.toLowerCase().localeCompare(b.name.toLowerCase())).forEach(qrs=>{
+                QuickReplySet.list.toSorted((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase())).forEach(qrs => {
                     const opt = document.createElement('option'); {
                         opt.value = qrs.name;
                         opt.textContent = qrs.name;

                 const cb = document.createElement('input'); {
                     cb.type = 'checkbox';
                     cb.checked = this.isVisible;
-                    cb.addEventListener('click', ()=>{
+                    cb.addEventListener('click', () => {
                         this.isVisible = cb.checked;
                         this.update();
                     });

                 edit.classList.add('fa-solid');
                 edit.classList.add('fa-pencil');
                 edit.title = 'Edit quick reply set';
-                edit.addEventListener('click', ()=>this.requestEditSet());
+                edit.addEventListener('click', () => this.requestEditSet());
                 item.append(edit);
+            }
             const del = document.createElement('div'); {

@@ -86,7 +82,7 @@ export class QuickReplySetLink {
86	del.classList.add('fa-solid');	82	del.classList.add('fa-solid');
87	del.classList.add('fa-trash-can');	83	del.classList.add('fa-trash-can');
88	del.title = 'Remove quick reply set';	84	del.title = 'Remove quick reply set';
89	del.addEventListener('click', ()=>this.delete());	85	del.addEventListener('click', () => this.delete());
90	item.append(del);	86	item.append(del);
91	}	87	}
92	}	88	}

@@ -98,8 +94,6 @@ export class QuickReplySetLink {
98	}	94	}
99		95
100		96
101
102
103	update() {	97	update() {
104	if (this.onUpdate) {	98	if (this.onUpdate) {
105	this.onUpdate(this);	99	this.onUpdate(this);

@@ -118,8 +112,6 @@ export class QuickReplySetLink {
118	}	112	}
119		113
120		114
121
122
123	toJSON() {	115	toJSON() {
124	return {	116	return {
125	set: this.set.name,	117	set: this.set.name,

public/scripts/extensions/quick-reply/src/QuickReplySettings.js+2 -8 Viewed

@@ -15,8 +15,6 @@ export class QuickReplySettings {
15	}	15	}
16		16
17		17
18
19
20	/*@type {Boolean}/ isEnabled = false;	18	/*@type {Boolean}/ isEnabled = false;
21	/*@type {Boolean}/ isCombined = false;	19	/*@type {Boolean}/ isCombined = false;
22	/*@type {Boolean}/ isPopout = false;	20	/*@type {Boolean}/ isPopout = false;

     /**@type {Function}*/ onRequestEditSet;
     init() {
         this.hookConfig(this.config);
         this.hookConfig(this.chatConfig);

@@ -60,8 +56,8 @@ export class QuickReplySettings {
60		56
61	hookConfig(config) {	57	hookConfig(config) {
62	if (config) {	58	if (config) {
63	config.onUpdate = ()=>this.save();	59	config.onUpdate = () => this.save();
64	config.onRequestEditSet = (qrs)=>this.requestEditSet(qrs);	60	config.onRequestEditSet = (qrs) => this.requestEditSet(qrs);
65	}	61	}
66	}	62	}
67	unhookConfig(config) {	63	unhookConfig(config) {

@@ -72,8 +68,6 @@ export class QuickReplySettings {
72	}	68	}
73		69
74		70
75
76
77	save() {	71	save() {
78	extension_settings.quickReplyV2 = this.toJSON();	72	extension_settings.quickReplyV2 = this.toJSON();
79	saveSettingsDebounced();	73	saveSettingsDebounced();

public/scripts/extensions/quick-reply/src/SlashCommandHandler.js+13 -21 Viewed

     /** @type {QuickReplyApi} */ api;
     constructor(/** @type {QuickReplyApi} */api) {
         this.api = api;
+    }
     init() {
         function getExecutionIcons(/** @type {QuickReply} */ qr) {
             let icons = '';

             qrIds: (executor) => QuickReplySet.get(String(executor.namedArgumentList.find(x => x.name == 'set')?.value))?.qrList.map(qr => {
                 const icons = getExecutionIcons(qr);
                 const message = `${qr.automationId ? `[${qr.automationId}]` : ''}${icons ? `[auto: ${icons}]` : ''} ${qr.title || qr.message}`.trim();
-                return new SlashCommandEnumValue(qr.label, message, enumTypes.enum, enumIcons.qr, null, ()=>qr.id.toString(), true);
+                return new SlashCommandEnumValue(qr.label, message, enumTypes.enum, enumIcons.qr, null, () => qr.id.toString(), true);
             }) ?? [],
             /** All QRs as a set.name string, to be able to execute, for example via the /run command */

                 return '';
             },
             returns: 'updated quick reply',
-            namedArgumentList: [...qrUpdateArgs, ...qrArgs.map(it=>{
+            namedArgumentList: [...qrUpdateArgs, ...qrArgs.map(it => {
                 if (it.name == 'label') {
                     const clone = SlashCommandNamedArgument.fromProps(it);
                     clone.isRequired = false;

                 if (!args.from) throw new Error('/import requires from= to be set.');
                 if (!value) throw new Error('/import requires the unnamed argument to be set.');
                 let qr = [...this.api.listGlobalSets(), ...this.api.listChatSets()]
-                    .map(it=>this.api.getSetByName(it)?.qrList ?? [])
+                    .map(it => this.api.getSetByName(it)?.qrList ?? [])
                     .flat()
-                    .find(it=>it.label == args.from)
+                    .find(it => it.label == args.from)
+                ;
                 if (!qr) {
                     let [setName, ...qrNameParts] = args.from.split('.');
                     let qrName = qrNameParts.join('.');
                     let qrs = QuickReplySet.get(setName);
                     if (qrs) {
-                        qr = qrs.qrList.find(it=>it.label == qrName);
+                        qr = qrs.qrList.find(it => it.label == qrName);
+                    }
+                }
                 if (qr) {

                     if (args._debugController) {
                         closure.source = args.from;
+                    }
-                    const testCandidates = (executor)=>{
+                    const testCandidates = (executor) => {
                         return (
-                            executor.namedArgumentList.find(arg=>arg.name == 'key')
+                            executor.namedArgumentList.find(arg => arg.name == 'key')
                             && executor.unnamedArgumentList.length > 0
                             && executor.unnamedArgumentList[0].value instanceof SlashCommandClosure
                         ) || (
-                            !executor.namedArgumentList.find(arg=>arg.name == 'key')
+                            !executor.namedArgumentList.find(arg => arg.name == 'key')
                             && executor.unnamedArgumentList.length > 1
                             && executor.unnamedArgumentList[1].value instanceof SlashCommandClosure
                         );
                     };
                     const candidates = closure.executorList
-                        .filter(executor=>['let', 'var'].includes(executor.command.name))
+                        .filter(executor => ['let', 'var'].includes(executor.command.name))
                         .filter(testCandidates)
-                        .map(executor=>({
+                        .map(executor => ({
-                            key: executor.namedArgumentList.find(arg=>arg.name == 'key')?.value ?? executor.unnamedArgumentList[0].value,
+                            key: executor.namedArgumentList.find(arg => arg.name == 'key')?.value ?? executor.unnamedArgumentList[0].value,
-                            value: executor.unnamedArgumentList[executor.namedArgumentList.find(arg=>arg.name == 'key') ? 0 : 1].value,
+                            value: executor.unnamedArgumentList[executor.namedArgumentList.find(arg => arg.name == 'key') ? 0 : 1].value,
                         }))
+                    ;
                     for (let i = 0; i < value.length; i++) {

                             dstName = value[i + 2];
                             i += 2;
+                        }
-                        const pick = candidates.find(it=>it.key == srcName);
+                        const pick = candidates.find(it => it.key == srcName);
                         if (!pick) throw new Error(`No scoped closure named "${srcName}" found in "${args.from}"`);
                         if (args._scope.existsVariableInScope(dstName)) {
                             args._scope.setVariable(dstName, pick.value);

@@ -783,8 +779,6 @@ export class SlashCommandHandler {
783	}	779	}
784		780
785		781
786
787
788	getSetByName(name) {	782	getSetByName(name) {
789	const set = this.api.getSetByName(name);	783	const set = this.api.getSetByName(name);
790	if (!set) {	784	if (!set) {

@@ -802,8 +796,6 @@ export class SlashCommandHandler {
802	}	796	}
803		797
804		798
805
806
807	async executeQuickReplyByIndex(idx) {	799	async executeQuickReplyByIndex(idx) {
808	try {	800	try {
809	return await this.api.executeQuickReplyByIndex(idx);	801	return await this.api.executeQuickReplyByIndex(idx);

public/scripts/extensions/quick-reply/src/ui/ButtonUi.js+6 -14 Viewed

     /**@type {HTMLElement}*/ popoutDom;
     constructor(/**@type {QuickReplySettings}*/settings) {
         this.settings = settings;
+    }
     render() {
         if (this.settings.isPopout) {
             return this.renderPopout();

@@ -57,8 +53,6 @@ export class ButtonUi {
57	}	53	}
58		54
59		55
60
61
62	renderBar() {	56	renderBar() {
63	if (!this.dom) {	57	if (!this.dom) {
64	let buttonHolder;	58	let buttonHolder;

                         popout.classList.add('menu_button');
                         popout.classList.add('fa-solid');
                         popout.classList.add('fa-window-restore');
-                        popout.addEventListener('click', ()=>{
+                        popout.addEventListener('click', () => {
                             this.settings.isPopout = true;
                             this.refresh();
                             this.settings.save();

@@ -91,8 +85,8 @@ export class ButtonUi {
91	}	85	}
92	}	86	}
93	[...this.settings.config.setList, ...(this.settings.chatConfig?.setList ?? []), ...(this.settings.charConfig?.setList ?? [])]	87	[...this.settings.config.setList, ...(this.settings.chatConfig?.setList ?? []), ...(this.settings.charConfig?.setList ?? [])]
94	.filter(link=>link.isVisible)	88	.filter(link => link.isVisible)
95	.forEach(link=>buttonHolder.append(link.set.render()))	89	.forEach(link => buttonHolder.append(link.set.render()))
96	;	90	;
97	}	91	}
98	}	92	}

@@ -100,8 +94,6 @@ export class ButtonUi {
100	}	94	}
101		95
102		96
103
104
105	renderPopout() {	97	renderPopout() {
106	if (!this.popoutDom) {	98	if (!this.popoutDom) {
107	let buttonHolder;	99	let buttonHolder;

                             close.classList.add('fa-solid');
                             close.classList.add('fa-circle-xmark');
                             close.classList.add('hoverglow');
-                            close.addEventListener('click', ()=>{
+                            close.addEventListener('click', () => {
                                 this.settings.isPopout = false;
                                 this.refresh();
                                 this.settings.save();

@@ -151,8 +143,8 @@ export class ButtonUi {
151	}	143	}
152	}	144	}
153	[...this.settings.config.setList, ...(this.settings.chatConfig?.setList ?? []), ...(this.settings.charConfig?.setList ?? [])]	145	[...this.settings.config.setList, ...(this.settings.chatConfig?.setList ?? []), ...(this.settings.charConfig?.setList ?? [])]
154	.filter(link=>link.isVisible)	146	.filter(link => link.isVisible)
155	.forEach(link=>buttonHolder.append(link.set.render()))	147	.forEach(link => buttonHolder.append(link.set.render()))
156	;	148	;
157	root.append(body);	149	root.append(body);
158	}	150	}

public/scripts/extensions/quick-reply/src/ui/SettingsUi.js+30 -38 Viewed

     /**@type {HTMLSelectElement}*/ currentSet;
     constructor(/**@type {QuickReplySettings}*/settings) {
         this.settings = settings;
         settings.onRequestEditSet = (qrs) => this.selectQrSet(qrs);
+    }
     rerender() {
         if (!this.dom) return;
         const content = this.dom.querySelector('.inline-drawer-content');
         content.innerHTML = '';
         // @ts-ignore
-        Array.from(this.template.querySelector('.inline-drawer-content').cloneNode(true).children).forEach(el=>{
+        Array.from(this.template.querySelector('.inline-drawer-content').cloneNode(true).children).forEach(el => {
             content.append(el);
         });
         this.prepareDom();

         // general settings
         this.isEnabled = this.dom.querySelector('#qr--isEnabled');
         this.isEnabled.checked = this.settings.isEnabled;
-        this.isEnabled.addEventListener('click', ()=>this.onIsEnabled());
+        this.isEnabled.addEventListener('click', () => this.onIsEnabled());
         this.isCombined = this.dom.querySelector('#qr--isCombined');
         this.isCombined.checked = this.settings.isCombined;
-        this.isCombined.addEventListener('click', ()=>this.onIsCombined());
+        this.isCombined.addEventListener('click', () => this.onIsCombined());
         this.showPopoutButton = this.dom.querySelector('#qr--showPopoutButton');
         this.showPopoutButton.checked = this.settings.showPopoutButton;
-        this.showPopoutButton.addEventListener('click', ()=>this.onShowPopoutButton());
+        this.showPopoutButton.addEventListener('click', () => this.onShowPopoutButton());
+    }
     prepareGlobalSetList() {

     prepareQrEditor() {
         // qr editor
         this.dom.querySelector('#qr--set-rename').addEventListener('click', async () => this.renameQrSet());
-        this.dom.querySelector('#qr--set-new').addEventListener('click', async()=>this.addQrSet());
+        this.dom.querySelector('#qr--set-new').addEventListener('click', async () => this.addQrSet());
         /**@type {HTMLInputElement}*/
         const importFile = this.dom.querySelector('#qr--set-importFile');
-        importFile.addEventListener('change', async()=>{
+        importFile.addEventListener('change', async () => {
             await this.importQrSet(importFile.files);
             importFile.value = null;
         });
-        this.dom.querySelector('#qr--set-import').addEventListener('click', ()=>importFile.click());
+        this.dom.querySelector('#qr--set-import').addEventListener('click', () => importFile.click());
         this.dom.querySelector('#qr--set-export').addEventListener('click', async () => this.exportQrSet());
         this.dom.querySelector('#qr--set-duplicate').addEventListener('click', async () => this.duplicateQrSet());
-        this.dom.querySelector('#qr--set-delete').addEventListener('click', async()=>this.deleteQrSet());
+        this.dom.querySelector('#qr--set-delete').addEventListener('click', async () => this.deleteQrSet());
-        this.dom.querySelector('#qr--set-add').addEventListener('click', async()=>{
+        this.dom.querySelector('#qr--set-add').addEventListener('click', async () => {
             this.currentQrSet.addQuickReply();
         });
-        this.dom.querySelector('#qr--set-paste').addEventListener('click', async()=>{
+        this.dom.querySelector('#qr--set-paste').addEventListener('click', async () => {
             const text = await navigator.clipboard.readText();
             this.currentQrSet.addQuickReplyFromText(text);
         });
-        this.dom.querySelector('#qr--set-importQr').addEventListener('click', async()=>{
+        this.dom.querySelector('#qr--set-importQr').addEventListener('click', async () => {
             const inp = document.createElement('input'); {
                 inp.type = 'file';
                 inp.accept = '.json';
-                inp.addEventListener('change', async()=>{
+                inp.addEventListener('change', async () => {
                     if (inp.files.length > 0) {
                         for (const file of inp.files) {
                             const text = await file.text();

         });
         this.qrList = this.dom.querySelector('#qr--set-qrList');
         this.currentSet = this.dom.querySelector('#qr--set');
-        this.currentSet.addEventListener('change', ()=>this.onQrSetChange());
+        this.currentSet.addEventListener('change', () => this.onQrSetChange());
-        QuickReplySet.list.toSorted((a,b)=>a.name.toLowerCase().localeCompare(b.name.toLowerCase())).forEach(qrs=>{
+        QuickReplySet.list.toSorted((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase())).forEach(qrs => {
             const opt = document.createElement('option'); {
                 opt.value = qrs.name;
                 opt.textContent = qrs.name;

+            }
         });
         this.disableSend = this.dom.querySelector('#qr--disableSend');
-        this.disableSend.addEventListener('click', ()=>{
+        this.disableSend.addEventListener('click', () => {
             const qrs = this.currentQrSet;
             qrs.disableSend = this.disableSend.checked;
             qrs.save();
         });
         this.placeBeforeInput = this.dom.querySelector('#qr--placeBeforeInput');
-        this.placeBeforeInput.addEventListener('click', ()=>{
+        this.placeBeforeInput.addEventListener('click', () => {
             const qrs = this.currentQrSet;
             qrs.placeBeforeInput = this.placeBeforeInput.checked;
             qrs.save();
         });
         this.injectInput = this.dom.querySelector('#qr--injectInput');
-        this.injectInput.addEventListener('click', ()=>{
+        this.injectInput.addEventListener('click', () => {
             const qrs = this.currentQrSet;
             qrs.injectInput = this.injectInput.checked;
             qrs.save();

         this.color = this.dom.querySelector('#qr--color');
         // @ts-ignore
         this.color.color = this.currentQrSet?.color ?? 'transparent';
-        this.color.addEventListener('change', (evt)=>{
+        this.color.addEventListener('change', (evt) => {
             if (!this.dom.closest('body')) return;
             const qrs = this.currentQrSet;
             if (initialColorChange) {

             this.currentQrSet.updateColor();
         });
         // @ts-ignore
-        this.dom.querySelector('#qr--colorClear').addEventListener('click', (evt)=>{
+        this.dom.querySelector('#qr--colorClear').addEventListener('click', (evt) => {
             const qrs = this.currentQrSet;
             // @ts-ignore
             this.color.color = 'transparent';

             this.currentQrSet.updateColor();
         });
         this.onlyBorderColor = this.dom.querySelector('#qr--onlyBorderColor');
-        this.onlyBorderColor.addEventListener('click', ()=>{
+        this.onlyBorderColor.addEventListener('click', () => {
             const qrs = this.currentQrSet;
             qrs.onlyBorderColor = this.onlyBorderColor.checked;
             qrs.save();

         $(qrsDom).sortable({
             delay: getSortableDelay(),
             handle: '.drag-handle',
-            stop: ()=>this.onQrListSort(),
+            stop: () => this.onQrListSort(),
         });
+    }

@@ -256,8 +250,6 @@ export class SettingsUi {
256	}	250	}
257		251
258		252
259
260
261	async onIsEnabled() {	253	async onIsEnabled() {
262	this.settings.isEnabled = this.isEnabled.checked;	254	this.settings.isEnabled = this.isEnabled.checked;
263	this.settings.save();	255	this.settings.save();

+    }
     async onGlobalSetListSort() {
-        this.settings.config.setList = Array.from(this.globalSetList.children).map((it,idx)=>{
+        this.settings.config.setList = Array.from(this.globalSetList.children).map((it, idx) => {
             const set = this.settings.config.setList[Number(it.getAttribute('data-order'))];
             it.setAttribute('data-order', String(idx));
             return set;

+    }
     async onChatSetListSort() {
-        this.settings.chatConfig.setList = Array.from(this.chatSetList.children).map((it,idx)=>{
+        this.settings.chatConfig.setList = Array.from(this.chatSetList.children).map((it, idx) => {
             const set = this.settings.chatConfig.setList[Number(it.getAttribute('data-order'))];
             it.setAttribute('data-order', String(idx));
             return set;

+    }
     updateOrder(list) {
-        Array.from(list.children).forEach((it,idx)=>{
+        Array.from(list.children).forEach((it, idx) => {
             it.setAttribute('data-order', idx);
         });
+    }
     async onQrListSort() {
-        this.currentQrSet.qrList = Array.from(this.qrList.querySelectorAll('.qr--set-item')).map((it,idx)=>{
+        this.currentQrSet.qrList = Array.from(this.qrList.querySelectorAll('.qr--set-item')).map((it, idx) => {
-            const qr = this.currentQrSet.qrList.find(qr=>qr.id == Number(it.getAttribute('data-id')));
+            const qr = this.currentQrSet.qrList.find(qr => qr.id == Number(it.getAttribute('data-id')));
             it.setAttribute('data-order', String(idx));
             return qr;
         });

                 const qrs = new QuickReplySet();
                 qrs.name = name;
                 qrs.addQuickReply();
-                const idx = QuickReplySet.list.findIndex(it=>it.name.toLowerCase().localeCompare(name.toLowerCase()) == 1);
+                const idx = QuickReplySet.list.findIndex(it => it.name.toLowerCase().localeCompare(name.toLowerCase()) == 1);
                 if (idx > -1) {
                     QuickReplySet.list.splice(idx, 0, qrs);
                 } else {

             } else {
                 /**@type {QuickReplySet}*/
                 const qrs = QuickReplySet.from(JSON.parse(JSON.stringify(props)));
-                qrs.qrList = props.qrList.map(it=>QuickReply.from(it));
+                qrs.qrList = props.qrList.map(it => QuickReply.from(it));
                 qrs.init();
                 const oldQrs = QuickReplySet.get(props.name);
                 if (oldQrs) {

                         this.prepareCharacterSetList();
+                    }
                 } else {
-                    const idx = QuickReplySet.list.findIndex(it=>it.name.toLowerCase().localeCompare(qrs.name.toLowerCase()) == 1);
+                    const idx = QuickReplySet.list.findIndex(it => it.name.toLowerCase().localeCompare(qrs.name.toLowerCase()) == 1);
                     if (idx > -1) {
                         QuickReplySet.list.splice(idx, 0, qrs);
                     } else {

+    }
     exportQrSet() {
-        const blob = new Blob([JSON.stringify(this.currentQrSet)], { type:'application/json' });
+        const blob = new Blob([JSON.stringify(this.currentQrSet)], { type: 'application/json' });
         const url = URL.createObjectURL(blob);
         const a = document.createElement('a'); {
             a.href = url;

public/scripts/extensions/quick-reply/src/ui/ctx/ContextMenu.js+0 -4 Viewed

     /**@type {HTMLElement}*/ menu;
     constructor(/**@type {QuickReply}*/qr) {
         // this.itemList = items;
         this.itemList = this.build(qr).children;

@@ -104,8 +102,6 @@ export class ContextMenu {
104	}	102	}
105		103
106		104
107
108
109	show({ clientX, clientY }) {	105	show({ clientX, clientY }) {
110	if (this.isActive) return;	106	if (this.isActive) return;
111	this.isActive = true;	107	this.isActive = true;

public/scripts/extensions/quick-reply/src/ui/ctx/MenuItem.js+0 -3 Viewed

@@ -15,8 +15,6 @@ export class MenuItem {
15	/*@type {function}/ onExpand;	15	/*@type {function}/ onExpand;
16		16
17		17
18
19
20	/**	18	/**
21	*	19	*
22	* @param {?string} icon	20	* @param {?string} icon

@@ -80,7 +78,6 @@ export class MenuItem {
80	}	78	}
81	item.addEventListener('mouseover', () => sub.show(item));	79	item.addEventListener('mouseover', () => sub.show(item));
82	item.addEventListener('mouseleave', () => sub.hide());	80	item.addEventListener('mouseleave', () => sub.hide());
83
84	}	81	}
85	}	82	}
86	}	83	}

public/scripts/extensions/quick-reply/src/ui/ctx/SubMenu.js+0 -4 Viewed

@@ -9,8 +9,6 @@ export class SubMenu {
9	/*@type {HTMLElement}/ root;	9	/*@type {HTMLElement}/ root;
10		10
11		11
12
13
14	constructor(/*@type {MenuItem[]}/items) {	12	constructor(/*@type {MenuItem[]}/items) {
15	this.itemList = items;	13	this.itemList = items;
16	}	14	}

@@ -29,8 +27,6 @@ export class SubMenu {
29	}	27	}
30		28
31		29
32
33
34	show(/*@type {HTMLElement}/parent) {	30	show(/*@type {HTMLElement}/parent) {
35	if (this.isActive) return;	31	if (this.isActive) return;
36	this.isActive = true;	32	this.isActive = true;

public/scripts/extensions/regex/index.js+0 -1 Viewed

         const trailingText = text.substring(lastIndex);
         outputText += trailingText;
         highlightedOutput += escapeHtml(trailingText);
     } catch (e) {
         err = (err ? err + '; ' : '') + `Replace error: ${e.message}`;
         outputText = text; // Fallback

public/scripts/extensions/token-counter/index.js+0 -1 Viewed

         returns: 'number of tokens',
         helpString: 'Counts the number of tokens in the current chat.',
     }));
 });

public/scripts/extensions/tts/alltalk.js+0 -1 Viewed

                 // V2: Combine the endpoint with the relative path
                 return `${this.settings.provider_endpoint}${data.output_file_url}`;
+            }
         } catch (error) {
             console.error('[fetchTtsGeneration] Exception caught:', error);
             throw error;

public/scripts/extensions/tts/chatterbox.js+0 -3 Viewed

+            }
             this.setupEventListeners();
         } catch (error) {
             console.error('Error loading Chatterbox settings:', error);
             this.updateStatus('Offline');

             });
             await audio.play();
         } catch (error) {
             console.error('Error previewing voice:', error);
             this.updateStatus('Ready');

             // Return the response directly - SillyTavern expects a Response object
             return response;
         } catch (error) {
             console.error('Error in generateTts:', error);
             this.updateStatus('Ready');

public/scripts/extensions/tts/coqui.js+12 -13 Viewed

             .then(response => response.json())
             .then(json => {
                 coquiApiModels = json;
-                console.debug(DEBUG_PREFIX,'initialized coqui-api model list to', coquiApiModels);
+                console.debug(DEBUG_PREFIX, 'initialized coqui-api model list to', coquiApiModels);
             /*
             $('#coqui_api_language')
                 .find('option')

             .then(response => response.json())
             .then(json => {
                 coquiApiModelsFull = json;
-                console.debug(DEBUG_PREFIX,'initialized coqui-api full model list to', coquiApiModelsFull);
+                console.debug(DEBUG_PREFIX, 'initialized coqui-api full model list to', coquiApiModelsFull);
             /*
             $('#coqui_api_full_language')
                 .find('option')

@@ -197,7 +197,7 @@ class CoquiTtsProvider {
197	}	197	}
198		198
199	// Perform a simple readiness check by trying to fetch voiceIds	199	// Perform a simple readiness check by trying to fetch voiceIds
200	async checkReady(){	200	async checkReady() {
201	throwIfModuleMissing();	201	throwIfModuleMissing();
202	await this.fetchTtsVoiceObjects();	202	await this.fetchTtsVoiceObjects();
203	}	203	}

                 .append('<option value="none">Select model language</option>')
                 .val('none');
-            for(let language in coquiApiModels) {
+            for (let language in coquiApiModels) {
                 let languageLabel = language;
                 if (language in languageLabels)
                     languageLabel = languageLabels[language];
-                $('#coqui_api_language').append(new Option(languageLabel,language));
+                $('#coqui_api_language').append(new Option(languageLabel, language));
-                console.log(DEBUG_PREFIX,'added language',languageLabel,'(',language,')');
+                console.log(DEBUG_PREFIX, 'added language', languageLabel, '(', language, ')');
+            }
             $('#coqui_api_model_div').show();

                 .append('<option value="none">Select model language</option>')
                 .val('none');
-            for(let language in coquiApiModelsFull) {
+            for (let language in coquiApiModelsFull) {
                 let languageLabel = language;
                 if (language in languageLabels)
                     languageLabel = languageLabels[language];
-                $('#coqui_api_language').append(new Option(languageLabel,language));
+                $('#coqui_api_language').append(new Option(languageLabel, language));
-                console.log(DEBUG_PREFIX,'added language',languageLabel,'(',language,')');
+                console.log(DEBUG_PREFIX, 'added language', languageLabel, '(', language, ')');
+            }
             $('#coqui_api_model_div').show();

         if (model_origin == 'coqui-api-full')
             modelDict = coquiApiModelsFull;
-        for(let model_dataset in modelDict[model_language])
+        for (let model_dataset in modelDict[model_language])
-            for(let model_name in modelDict[model_language][model_dataset]) {
+            for (let model_name in modelDict[model_language][model_dataset]) {
                 const model_id = model_dataset + '/' + model_name;
                 const model_label = model_name + ' (' + model_dataset + ' dataset)';
                 $('#coqui_api_model_name').append(new Option(model_label, model_id));

         // Check if already installed and propose to do it otherwise
         const model_id = modelDict[model_language][model_dataset][model_name].id;
-        console.debug(DEBUG_PREFIX,'Check if model is already installed',model_id);
+        console.debug(DEBUG_PREFIX, 'Check if model is already installed', model_id);
         const result = await CoquiTtsProvider.checkmodel_state(model_id);
         const resultJSON = await result.json();
         const model_state = resultJSON.model_state;

@@ -583,7 +583,6 @@ class CoquiTtsProvider {
583	$('#coqui_api_model_install_button').show();	583	$('#coqui_api_model_install_button').show();
584	return;	584	return;
585	}	585	}
586
587	}	586	}
588		587
589		588

public/scripts/extensions/tts/cosyvoice.js+0 -6 Viewed

     //#################//
     async getVoice(voiceName) {
         if (this.voices.length == 0) {
             this.voices = await this.fetchTtsVoiceObjects();
+        }
         const match = this.voices.filter(
             v => v.name == voiceName,
         )[0];

@@ -130,7 +126,6 @@ class CosyVoiceProvider {
130	}	126	}
131		127
132		128
133
134	async generateTts(text, voiceId) {	129	async generateTts(text, voiceId) {
135	const response = await this.fetchTtsGeneration(text, voiceId);	130	const response = await this.fetchTtsGeneration(text, voiceId);
136	return response;	131	return response;

@@ -198,7 +193,6 @@ class CosyVoiceProvider {
198	}	193	}
199		194
200		195
201
202	// Interface not used	196	// Interface not used
203	async fetchTtsFromHistory(history_item_id) {	197	async fetchTtsFromHistory(history_item_id) {
204	return Promise.resolve(history_item_id);	198	return Promise.resolve(history_item_id);

public/scripts/extensions/tts/elevenlabs.js+1 -1 Viewed

@@ -132,7 +132,7 @@ class ElevenLabsTtsProvider {
132	}	132	}
133		133
134	if (Object.hasOwn(settings, 'apiKey')) {	134	if (Object.hasOwn(settings, 'apiKey')) {
135	if (settings.apiKey && !secret_state[SECRET_KEYS.ELEVENLABS]){	135	if (settings.apiKey && !secret_state[SECRET_KEYS.ELEVENLABS]) {
136	await writeSecret(SECRET_KEYS.ELEVENLABS, settings.apiKey);	136	await writeSecret(SECRET_KEYS.ELEVENLABS, settings.apiKey);
137	}	137	}
138	delete settings.apiKey;	138	delete settings.apiKey;

public/scripts/extensions/tts/google-native.js+0 -2 Viewed

             console.info(`Google TTS: Loaded ${this.voices.length} voices`);
             return this.voices;
         } catch (error) {
             console.error('Failed to fetch Google TTS voices:', error);
             throw error;

             this.audioElement.src = url;
             this.audioElement.play();
             this.audioElement.onended = () => URL.revokeObjectURL(url);
         } catch (error) {
             console.error('TTS Preview Error:', error);
             toastr.error(`Could not generate preview: ${error.message}`);

public/scripts/extensions/tts/gpt-sovits-v2.js+0 -8 Viewed

     //#################//
     async getVoice(voiceName) {
         if (this.voices.length == 0) {
             this.voices = await this.fetchTtsVoiceObjects();
+        }
         const match = this.voices.filter(
             v => v.name == voiceName,
         )[0];

@@ -135,7 +131,6 @@ class GptSovitsV2Provider {
135	}	131	}
136		132
137		133
138
139	async generateTts(text, voiceId) {	134	async generateTts(text, voiceId) {
140	const response = await this.fetchTtsGeneration(text, voiceId);	135	const response = await this.fetchTtsGeneration(text, voiceId);
141	return response;	136	return response;

      */
     async fetchTtsGeneration(inputText, voiceId, lang = null, forceNoStreaming = false) {
         console.info(`Generating new TTS for voice_id ${voiceId}`);

@@ -215,7 +208,6 @@ class GptSovitsV2Provider {
215	}	208	}
216		209
217		210
218
219	// Interface not used	211	// Interface not used
220	async fetchTtsFromHistory(history_item_id) {	212	async fetchTtsFromHistory(history_item_id) {
221	return Promise.resolve(history_item_id);	213	return Promise.resolve(history_item_id);

public/scripts/extensions/tts/gsvi.js+0 -9 Viewed

@@ -1,4 +1,3 @@
1
2	import { saveTtsProviderSettings } from './index.js';	1	import { saveTtsProviderSettings } from './index.js';
3		2
4	export { GSVITtsProvider };	3	export { GSVITtsProvider };

         const characterList = await response.json();
         this.characterList = characterList;
         this.voices = Object.keys(characterList);
+    }
     get settingsHtml() {
         let html = `
         <label for="gsvi_api_language">Text Language</label>

         $('#gsvi_batch_size_output').text(this.settings.batch_size);
         // Persist settings changes
         saveTtsProviderSettings();
+    }
     async loadSettings(settings) {

@@ -197,7 +191,6 @@ class GSVITtsProvider {
197	}	191	}
198		192
199		193
200
201	// Perform a simple readiness check by trying to fetch voiceIds	194	// Perform a simple readiness check by trying to fetch voiceIds
202	async checkReady() {	195	async checkReady() {
203	await Promise.allSettled([this.fetchCharacterList()]);	196	await Promise.allSettled([this.fetchCharacterList()]);

@@ -256,12 +249,10 @@ class GSVITtsProvider {
256		249
257		250
258	return `${this.settings.provider_endpoint}/tts?${params.toString()}`;	251	return `${this.settings.provider_endpoint}/tts?${params.toString()}`;
259
260	}	252	}
261		253
262	// Interface not used by GSVI TTS	254	// Interface not used by GSVI TTS
263	async fetchTtsFromHistory(history_item_id) {	255	async fetchTtsFromHistory(history_item_id) {
264	return Promise.resolve(history_item_id);	256	return Promise.resolve(history_item_id);
265	}	257	}
266
267	}	258	}

public/scripts/extensions/tts/index.js+0 -4 Viewed

             // Pass the full voiceMapKey (e.g., "User ("Quotes")") as well with character name
             await tts(segmentText, voiceId, char, voiceMapKey);
         } catch (error) {
             toastr.error(error.toString());
             console.error(error);

         // Clear current job so the segmented jobs can be processed
         currentTtsJob = null;
     } catch (error) {
         toastr.error(error.toString());
         console.error(error);

@@ -1286,7 +1284,6 @@ export function getCharacters(unrestricted) {
1286	}	1284	}
1287		1285
1288	return characters;	1286	return characters;
1289
1290	}	1287	}
1291		1288
1292	export function sanitizeId(input) {	1289	export function sanitizeId(input) {

@@ -1314,7 +1311,6 @@ function parseVoiceMap(voiceMapString) {
1314	}	1311	}
1315		1312
1316		1313
1317
1318	/**	1314	/**
1319	* Apply voiceMap based on current voiceMapEntries	1315	* Apply voiceMap based on current voiceMapEntries
1320	*/	1316	*/

public/scripts/extensions/tts/kokoro-worker.js+1 -1 Viewed

 let voices = [];
 // Handle messages from the main thread
-self.onmessage = async function(e) {
+self.onmessage = async function (e) {
     const { action, data } = e.data;
     switch (action) {

public/scripts/extensions/tts/minimax.js+0 -2 Viewed

             // Backend handles all the complex processing and returns audio data directly
             console.debug('MiniMax TTS: Audio response received from backend');
             return response;
         } catch (error) {
             console.error('Error in MiniMax TTS generation:', error);
             throw error;

                 this.audioElement.onended = null;
                 this.audioElement.onerror = null;
             };
         } catch (error) {
             console.error('MiniMax TTS Preview Error:', error);
             toastr.error(`Could not generate preview: ${error.message}`);

public/scripts/extensions/tts/openai.js+0 -1 Viewed

@@ -146,7 +146,6 @@ class OpenAITtsProvider {
146	}	146	}
147		147
148	populateCharacterInstructions() {	148	populateCharacterInstructions() {
149
150	const currentCharacters = $('.tts_voicemap_block_char span').map((i, el) => $(el).text()).get();	149	const currentCharacters = $('.tts_voicemap_block_char span').map((i, el) => $(el).text()).get();
151		150
152	$('#openai-character-instructions').empty();	151	$('#openai-character-instructions').empty();

public/scripts/extensions/tts/silerotts.js+0 -1 Viewed

@@ -172,5 +172,4 @@ class SileroTtsProvider {
172	async fetchTtsFromHistory(history_item_id) {	172	async fetchTtsFromHistory(history_item_id) {
173	return Promise.resolve(history_item_id);	173	return Promise.resolve(history_item_id);
174	}	174	}
175
176	}	175	}

public/scripts/extensions/tts/xtts.js+0 -1 Viewed

@@ -323,5 +323,4 @@ class XTTSTtsProvider {
323	async fetchTtsFromHistory(history_item_id) {	323	async fetchTtsFromHistory(history_item_id) {
324	return Promise.resolve(history_item_id);	324	return Promise.resolve(history_item_id);
325	}	325	}
326
327	}	326	}

public/scripts/extensions/vectors/index.js+0 -1 Viewed

@@ -1456,7 +1456,6 @@ async function onViewStatsClick() {
1456	messageElement.addClass('vectorized');	1456	messageElement.addClass('vectorized');
1457	}	1457	}
1458	}	1458	}
1459
1460	}	1459	}
1461		1460
1462	async function onVectorizeAllFilesClick() {	1461	async function onVectorizeAllFilesClick() {

public/scripts/f-localStorage.js+0 -1 Viewed

 export function LoadLocal(target) {
     console.debug('LoadLocal -- ' + target);
     return localStorage.getItem(target);
+}
 /**
  * @deprecated THIS FUNCTION IS OBSOLETE. DO NOT USE

public/scripts/filters.js+0 -1 Viewed

  * data = filterHelper.applyFilters(data);
  */
 export class FilterHelper {
     /**
      * Cache fuzzy search weighting scores for re-usability, sorting and stuff
+     *

public/scripts/group-chats.js+0 -1 Viewed

         const value = $(this).prop('checked');
         hideMutedSprites = value;
         onHideMutedSpritesClick(value);
     });
     $('#send_textarea').on('keyup', onSendTextareaInput);
     $('#groupCurrentMemberPopoutButton').on('click', doCurMemberListPopout);

public/scripts/input-md-formatting.js+4 -5 Viewed

         let cursorShift = charsToAdd.length;
         let selectedTextandPossibleFormatting = textarea.value.substring(start - possiblePreviousFormattingMargin, end + possiblePreviousFormattingMargin).trim();
-        if (isTextSelected) { //if text is selected
+        if (isTextSelected) {
+            //if text is selected
             selectedText = textarea.value.substring(start, end);
             if (selectedTextandPossibleFormatting === charsToAdd + selectedText + charsToAdd) {
                 // If the selected text is already formatted, remove the formatting

                 textarea.focus();
                 document.execCommand('insertText', false, charsToAdd + selectedText + charsToAdd + possibleAddedSpace);
+            }
-        } else {// No text is selected
+        } else {
+            // No text is selected
             //check 1 character before and after the cursor for non-space characters
             if (beforeCaret !== ' ' && afterCaret !== ' ' && afterCaret !== '' && beforeCaret !== '') { //look for caret in the middle of a word

+                }
                 if (charsToAdd + discoveredWord + charsToAdd === discoveredWordWithPossibleFormatting) {
                     // Replace the expanded selection with the original discovered word
                     textarea.focus();
                     document.execCommand('insertText', false, discoveredWord);

                     textarea.focus();
                     document.execCommand('insertText', false, charsToAdd + discoveredWord + charsToAdd);
+                }
             } else { //caret is not inside a word, so just add the formatting
                 textarea.focus();
                 textarea.setSelectionRange(start, end);

public/scripts/instruct-mode.js+0 -1 Viewed

             $('#instruct_system_sequence').prop('readOnly', false);
             $('#instruct_system_suffix').prop('readOnly', false);
+        }
     });
     $('#instruct_enabled').on('change', function () {

public/scripts/openai.js+0 -4 Viewed

@@ -2279,7 +2279,6 @@ function appendElectronHubOptions(model_list, groupModels = false) {
2279	appendOption(model);	2279	appendOption(model);
2280	});	2280	});
2281	}	2281	}
2282
2283	}	2282	}
2284		2283
2285	function electronHubSortBy(data, property = 'alphabetically') {	2284	function electronHubSortBy(data, property = 'alphabetically') {

         option.value = i;
         option.text = item;
         $('#settings_preset_openai').append(option);
     });
     openai_setting_names = settingNames;

@@ -4896,7 +4894,6 @@ function getSiliconflowMaxContext(model, isUnlocked) {
4896		4894
4897	// Return context size if model found, otherwise default to 32k	4895	// Return context size if model found, otherwise default to 32k
4898	return Object.entries(contextMap).find(([key]) => model.includes(key))?.[1] \|\| max_32k;	4896	return Object.entries(contextMap).find(([key]) => model.includes(key))?.[1] \|\| max_32k;
4899
4900	}	4897	}
4901		4898
4902	/**	4899	/**

         console.log('Claude model changed to', value);
         oai_settings.claude_model = value;
         $('#model_claude_select').val(oai_settings.claude_model);
+    }
     if ($(this).is('#model_openai_select')) {

public/scripts/personas.js+0 -2 Viewed

         highlightPersonas: true,
         targetedChar: getCurrentConnectionObj(),
         shiftClickHandler: (element, ev) => {
             const personaId = $(element).attr('data-pid');
             /** @type {PersonaConnection[]} */

     if (isFalseBoolean(value)) {
         await setPersonaLockState(false, type);
         return 'false';
+    }
     return '';

public/scripts/popup.js+0 -1 Viewed

@@ -478,7 +478,6 @@ export class Popup {
478	break;	478	break;
479	}	479	}
480	}	480	}
481
482	};	481	};
483	this.dlg.addEventListener('keydown', keyListener.bind(this));	482	this.dlg.addEventListener('keydown', keyListener.bind(this));
484	}	483	}

public/scripts/power-user.js+1 -8 Viewed

 var originalSliderValues = [];
 async function switchLabMode({ noReset = false } = {}) {
     /*     if (power_user.enableZenSliders && power_user.enableLabMode) {
             toastr.warning("Can't start Lab Mode while Zen Sliders are active")
             return

         $('#amount_gen').attr('min', '1')
             .attr('max', '99999')
             .attr('step', '1');
     } else if (!noReset) {
         //re apply the original sliders values to each input
         originalSliderValues.forEach(function (slider) {

@@ -628,7 +625,6 @@ async function switchZenSliders() {
628	});	625	});
629	$('div[id$="_zenslider"]').remove();	626	$('div[id$="_zenslider"]').remove();
630	}	627	}
631
632	}	628	}
633	async function CreateZenSliders(elmnt) {	629	async function CreateZenSliders(elmnt) {
634	var originalSlider = elmnt;	630	var originalSlider = elmnt;

     document.documentElement.style.setProperty('--shadowWidth', String(power_user.shadow_width));
     $('#shadow_width_counter').val(power_user.shadow_width);
     $('#shadow_width').val(power_user.shadow_width);
+}
 function applyFontScale(type) {

         } */
     function getAverageRGB(imgEl) {
         var blockSize = 5, // only visit every 5 pixels
             defaultRGB = { r: 0, g: 0, b: 0 }, // for non-supporting envs
             canvas = document.createElement('canvas'),

@@ -2994,7 +2988,6 @@ function setAvgBG() {
2994	rgb.b = ~~(rgb.b / count);	2988	rgb.b = ~~(rgb.b / count);
2995		2989
2996	return rgb;	2990	return rgb;
2997
2998	}	2991	}
2999		2992
3000	/**	2993	/**

             return;
+        }
-        eventSource.once(event_types.SETTINGS_UPDATED, function() {
+        eventSource.once(event_types.SETTINGS_UPDATED, function () {
             toastr.warning(
                 t`Click here to reload.`,
                 t`Toggling the Experimental Macro Engine requires a reload.`,

public/scripts/preset-manager.js+0 -1 Viewed

@@ -514,7 +514,6 @@ class PresetManager {
514	console.error('Preset could not be renamed', error);	514	console.error('Preset could not be renamed', error);
515	throw new Error('Preset could not be renamed');	515	throw new Error('Preset could not be renamed');
516	}	516	}
517
518	}	517	}
519		518
520	/**	519	/**

public/scripts/reasoning.js+0 -1 Viewed

     UI.$select.val(foundName).trigger('change');
     !quiet && toastr.success(`Reasoning template "${foundName}" selected`);
     return foundName;
+}
 function registerReasoningSlashCommands() {

public/scripts/samplerSelect.js+0 -1 Viewed

@@ -203,7 +203,6 @@ function setSamplerListListeners() {
203		203
204	console.log(samplerName, relatedDOMElement.data(SELECT_SAMPLER.DATA), shouldDisplay);	204	console.log(samplerName, relatedDOMElement.data(SELECT_SAMPLER.DATA), shouldDisplay);
205	});	205	});
206
207	}	206	}
208		207
209	function isElementVisibleInDOM(element) {	208	function isElementVisibleInDOM(element) {

public/scripts/showdown-underscore.js+1 -1 Viewed

         return [{
             type: 'output',
             regex: new RegExp('(<code(?:\\s+[^>]*)?>[\\s\\S]*?<\\/code>|<style(?:\\s+[^>]*)?>[\\s\\S]*?<\\/style>)|\\b(?<!_)_(?!_)(.*?)(?<!_)_(?!_)\\b', 'gi'),
-            replace: function(match, tagContent, italicContent) {
+            replace: function (match, tagContent, italicContent) {
                 if (tagContent) {
                     // If it's inside <code> or <style> tags, return unchanged
                     return match;

public/scripts/slash-commands.js+0 -2 Viewed

+}
 export async function promptQuietForLoudResponse(who, text) {
     let character_id = getContext().characterId;
     if (who === 'sys') {
         text = 'System: ' + text;

     addOneMessage(message);
     await eventSource.emit(event_types.USER_MESSAGE_RENDERED, (chat.length - 1));
     await saveChatConditional();
+}
 async function sendCommentMessage(args, text) {

public/scripts/slash-commands/SlashCommand.js+3 -6 Viewed

 */
 export class SlashCommand {
     /**
      * Creates a SlashCommand from a properties object.

@@ -48,8 +47,6 @@ export class SlashCommand {
48	}	47	}
49		48
50		49
51
52
53	/*@type {string}/ name;	50	/*@type {string}/ name;
54	/*@type {(namedArguments:NamedArguments, unnamedArguments:UnnamedArguments)=>string\|SlashCommandClosure\|Promise<string\|SlashCommandClosure>}/ callback;	51	/*@type {(namedArguments:NamedArguments, unnamedArguments:UnnamedArguments)=>string\|SlashCommandClosure\|Promise<string\|SlashCommandClosure>}/ callback;
55	/*@type {string}/ helpString;	52	/*@type {string}/ helpString;

                         name.classList.add('name');
                         name.classList.add('monospace');
                         name.textContent = '/';
-                        key.split('').forEach(char=>{
+                        key.split('').forEach(char => {
                             const span = document.createElement('span'); {
                                 span.textContent = char;
                                 name.append(span);

             const unnamedArguments = cmd.unnamedArgumentList ?? [];
             const returnType = cmd.returns ?? 'void';
             const helpString = cmd.helpString ?? 'NO DETAILS';
-            const aliasList = [cmd.name, ...(cmd.aliases ?? [])].filter(it=>it != key);
+            const aliasList = [cmd.name, ...(cmd.aliases ?? [])].filter(it => it != key);
             const specs = document.createElement('div'); {
                 specs.classList.add('specs');
                 const head = document.createElement('div'); {

                             this.isExtension ? 'Extension' : 'Core',
                             this.isThirdParty ? 'Third Party' : (this.isExtension ? 'Core' : null),
                             this.source,
-                        ].filter(it=>it).join('\n');
+                        ].filter(it => it).join('\n');
                         head.append(src);
+                    }
                     if (this.rawQuotes) {

public/scripts/slash-commands/SlashCommandArgument.js+1 -2 Viewed

 import { SlashCommandScope } from './SlashCommandScope.js';
 /**@readonly*/
 /**@enum {string}*/
 export const ARGUMENT_TYPE = {

         this.isRequired = isRequired ?? false;
         this.acceptsMultiple = acceptsMultiple ?? false;
         this.defaultValue = defaultValue;
-        this.enumList = (enums ? Array.isArray(enums) ? enums : [enums] : []).map(it=>{
+        this.enumList = (enums ? Array.isArray(enums) ? enums : [enums] : []).map(it => {
             if (it instanceof SlashCommandEnumValue) return it;
             return new SlashCommandEnumValue(it);
         });

public/scripts/slash-commands/SlashCommandAutoCompleteNameResult.js+13 -13 Viewed

             executor.start,
             Object
                 .keys(commands)
-                .map(key=>new SlashCommandCommandAutoCompleteOption(commands[key], key))
+                .map(key => new SlashCommandCommandAutoCompleteOption(commands[key], key))
+            ,
             false,
-            ()=>`No matching slash commands for "/${this.name}"`,
+            () => `No matching slash commands for "/${this.name}"`,
-            ()=>'No slash commands found!',
+            () => 'No slash commands found!',
         );
         this.executor = executor;
         this.scope = scope;

         if (!Array.isArray(this.executor.command?.namedArgumentList)) {
             return null;
+        }
-        const notProvidedNamedArguments = this.executor.command.namedArgumentList.filter(arg=>!this.executor.namedArgumentList.find(it=>it.name == arg.name));
+        const notProvidedNamedArguments = this.executor.command.namedArgumentList.filter(arg => !this.executor.namedArgumentList.find(it => it.name == arg.name));
         let name;
         let value;
         let start;

         const namedArgsFollowedBySpace = text[this.executor.endNamedArgs] == ' ';
         if (this.executor.startNamedArgs <= index && this.executor.endNamedArgs + (namedArgsFollowedBySpace ? 1 : 0) >= index) {
             // cursor is somewhere within the named arguments (including final space)
-            argAssign = this.executor.namedArgumentList.find(it=>it.start <= index && it.end >= index);
+            argAssign = this.executor.namedArgumentList.find(it => it.start <= index && it.end >= index);
             if (argAssign) {
                 const [argName, ...v] = text.slice(argAssign.start, index).split(getSplitRegex());
                 name = argName;
                 value = v.join('');
                 start = argAssign.start;
-                cmdArg = this.executor.command.namedArgumentList.find(it=>[it.name, `${it.name}=`].includes(argAssign.name));
+                cmdArg = this.executor.command.namedArgumentList.find(it => [it.name, `${it.name}=`].includes(argAssign.name));
                 if (cmdArg) notProvidedNamedArguments.push(cmdArg);
             } else {
                 name = '';

             // if cursor is already behind "=" check for enums
             const enumList = cmdArg?.enumProvider?.(this.executor, this.scope) ?? cmdArg?.enumList;
             if (cmdArg && enumList?.length) {
-                if (isSelect && enumList.find(it=>it.value == value) && argAssign && argAssign.end == index) {
+                if (isSelect && enumList.find(it => it.value == value) && argAssign && argAssign.end == index) {
                     return null;
+                }
                 const result = new AutoCompleteSecondaryNameResult(
                     value,
                     start + name.length,
-                    enumList.map(it=>SlashCommandEnumAutoCompleteOption.from(this.executor.command, it)),
+                    enumList.map(it => SlashCommandEnumAutoCompleteOption.from(this.executor.command, it)),
                     true,
                 );
                 result.isRequired = true;

             const result = new AutoCompleteSecondaryNameResult(
                 name,
                 start,
-                notProvidedNamedArguments.map(it=>new SlashCommandNamedArgumentAutoCompleteOption(it, this.executor.command)),
+                notProvidedNamedArguments.map(it => new SlashCommandNamedArgumentAutoCompleteOption(it, this.executor.command)),
                 false,
             );
-            result.isRequired = notProvidedNamedArguments.find(it=>it.isRequired) != null;
+            result.isRequired = notProvidedNamedArguments.find(it => it.isRequired) != null;
             return result;
+        }

         let argAssign;
         if (this.executor.startUnnamedArgs <= index && this.executor.endUnnamedArgs + 1 >= index) {
             // cursor is somwehere in the unnamed args
-            const idx = this.executor.unnamedArgumentList.findIndex(it=>it.start <= index && it.end >= index);
+            const idx = this.executor.unnamedArgumentList.findIndex(it => it.start <= index && it.end >= index);
             if (idx > -1) {
                 argAssign = this.executor.unnamedArgumentList[idx];
                 cmdArg = this.executor.command.unnamedArgumentList[idx];

         const result = new AutoCompleteSecondaryNameResult(
             value,
             start,
-            enumList.map(it=>SlashCommandEnumAutoCompleteOption.from(this.executor.command, it)),
+            enumList.map(it => SlashCommandEnumAutoCompleteOption.from(this.executor.command, it)),
             false,
         );
-        const isCompleteValue = enumList.find(it=>it.value == value);
+        const isCompleteValue = enumList.find(it => it.value == value);
         const isSelectedValue = isSelect && isCompleteValue;
         result.isRequired = cmdArg.isRequired && !isSelectedValue;
         result.forceMatch = cmdArg.forceEnum;

public/scripts/slash-commands/SlashCommandBrowser.js+15 -15 Viewed

                             inp.classList.add('text_pole');
                             inp.type = 'search';
                             inp.placeholder = 'Search slash commands - use quotes to search "literal" instead of fuzzy';
-                            inp.addEventListener('input', ()=>{
+                            inp.addEventListener('input', () => {
                                 this.details?.remove();
                                 this.details = null;
                                 let query = inp.value.trim();

                                     const match = queryRegex.exec(query);
                                     if (!match) break;
                                     if (match[1] !== undefined) {
-                                        fuzzyList.push(new RegExp(`^(.*?)${match[1].split('').map(char=>`(${escapeRegex(char)})`).join('(.*?)')}(.*?)$`, 'i'));
+                                        fuzzyList.push(new RegExp(`^(.*?)${match[1].split('').map(char => `(${escapeRegex(char)})`).join('(.*?)')}(.*?)$`, 'i'));
                                     } else if (match[2] !== undefined) {
                                         quotedList.push(match[2]);
+                                    }

                                 for (const cmd of this.cmdList) {
                                     const targets = [
                                         cmd.name,
-                                        ...cmd.namedArgumentList.map(it=>it.name),
+                                        ...cmd.namedArgumentList.map(it => it.name),
-                                        ...cmd.namedArgumentList.map(it=>it.description),
+                                        ...cmd.namedArgumentList.map(it => it.description),
-                                        ...cmd.namedArgumentList.map(it=>it.enumList.map(e=>e.value)).flat(),
+                                        ...cmd.namedArgumentList.map(it => it.enumList.map(e => e.value)).flat(),
-                                        ...cmd.namedArgumentList.map(it=>it.typeList).flat(),
+                                        ...cmd.namedArgumentList.map(it => it.typeList).flat(),
-                                        ...cmd.unnamedArgumentList.map(it=>it.description),
+                                        ...cmd.unnamedArgumentList.map(it => it.description),
-                                        ...cmd.unnamedArgumentList.map(it=>it.enumList.map(e=>e.value)).flat(),
+                                        ...cmd.unnamedArgumentList.map(it => it.enumList.map(e => e.value)).flat(),
-                                        ...cmd.unnamedArgumentList.map(it=>it.typeList).flat(),
+                                        ...cmd.unnamedArgumentList.map(it => it.typeList).flat(),
                                         ...cmd.aliases,
                                         cmd.helpString,
                                     ];
-                                    const find = ()=>targets.find(t=>(fuzzyList.find(f=>f.test(t)) ?? quotedList.find(q=>t.includes(q))) !== undefined) !== undefined;
+                                    const find = () => targets.find(t => (fuzzyList.find(f => f.test(t)) ?? quotedList.find(q => t.includes(q))) !== undefined) !== undefined;
                                     if (fuzzyList.length + quotedList.length === 0 || find()) {
                                         this.itemMap[cmd.name].classList.remove('isFiltered');
                                     } else {

                             const item = cmd.renderHelpItem();
                             this.itemMap[cmd.name] = item;
                             let details;
-                            item.addEventListener('click', ()=>{
+                            item.addEventListener('click', () => {
                                 if (!details) {
                                     details = document.createElement('div'); {
                                         details.classList.add('autoComplete-detailsWrap');

@@ -97,7 +97,7 @@ export class SlashCommandBrowser {
97	}	97	}
98	}	98	}
99	if (this.details !== details) {	99	if (this.details !== details) {
100	Array.from(list.querySelectorAll('.selected')).forEach(it=>it.classList.remove('selected'));	100	Array.from(list.querySelectorAll('.selected')).forEach(it => it.classList.remove('selected'));
101	item.classList.add('selected');	101	item.classList.add('selected');
102	this.details?.remove();	102	this.details?.remove();
103	container.append(details);	103	container.append(details);

+        }
         parent.append(this.dom);
-        this.mo = new MutationObserver(muts=>{
+        this.mo = new MutationObserver(muts => {
-            if (muts.find(mut=>Array.from(mut.removedNodes).find(it=>it === this.dom || it.contains(this.dom)))) {
+            if (muts.find(mut => Array.from(mut.removedNodes).find(it => it === this.dom || it.contains(this.dom)))) {
                 this.mo.disconnect();
                 window.removeEventListener('keydown', boundHandler);
+            }
         });
-        this.mo.observe(document.querySelector('#chat'), { childList:true, subtree:true });
+        this.mo.observe(document.querySelector('#chat'), { childList: true, subtree: true });
         const boundHandler = this.handleKeyDown.bind(this);
         window.addEventListener('keydown', boundHandler);
         return this.dom;

public/scripts/slash-commands/SlashCommandClosure.js+17 -17 Viewed

     /**@type {number}*/
     get commandCount() {
-        return this.executorList.map(executor=>executor.commandCount).reduce((sum,cur)=>sum + cur, 0);
+        return this.executorList.map(executor => executor.commandCount).reduce((sum, cur) => sum + cur, 0);
+    }
     constructor(parent) {

         let isList = false;
         let listValues = [];
         scope = scope ?? this.scope;
-        const escapeMacro = (it, isAnchored = false)=>{
+        const escapeMacro = (it, isAnchored = false) => {
             const regexText = escapeRegex(it.key.replace(/\*/g, '~~~WILDCARD~~~'))
                 .replaceAll('~~~WILDCARD~~~', '(?:(?:(?!(?:::|}})).)*)')
+            ;

+            }
             return regexText;
         };
-        const macroList = scope.macroList.toSorted((a,b)=>{
+        const macroList = scope.macroList.toSorted((a, b) => {
             if (a.key.includes('*') && !b.key.includes('*')) return 1;
             if (!a.key.includes('*') && b.key.includes('*')) return -1;
             if (a.key.includes('*') && b.key.includes('*')) return b.key.indexOf('*') - a.key.indexOf('*');

         if (power_user.experimental_macro_engine) {
             return this.substituteWithMacroEngine(text, scope, macroList);
+        }
-        const macros = macroList.map(it=>escapeMacro(it)).join('|');
+        const macros = macroList.map(it => escapeMacro(it)).join('|');
         const re = new RegExp(`(?<pipe>{{pipe}})|(?:{{var::(?<var>[^\\s]+?)(?:::(?<varIndex>(?!}}).+))?}})|(?:{{(?<macro>${macros})}})`);
         let done = '';
         let remaining = text;

             const match = re.exec(remaining);
             const before = substituteParams(remaining.slice(0, match.index));
             const after = remaining.slice(match.index + match[0].length);
-            const replacer = match.groups.pipe ? scope.pipe : match.groups.var ? scope.getVariable(match.groups.var, match.groups.index) : macroList.find(it=>it.key == match.groups.macro || new RegExp(escapeMacro(it, true)).test(match.groups.macro))?.value;
+            const replacer = match.groups.pipe ? scope.pipe : match.groups.var ? scope.getVariable(match.groups.var, match.groups.index) : macroList.find(it => it.key == match.groups.macro || new RegExp(escapeMacro(it, true)).test(match.groups.macro))?.value;
             if (replacer instanceof SlashCommandClosure) {
                 replacer.abortController = this.abortController;
                 replacer.breakController = this.breakController;

         return step.value;
+    }
-    async * executeDirect() {
+    async* executeDirect() {
         this.debugController?.down(this);
         // closure arguments
         for (const arg of this.argumentList) {

                     // breakpoint has to yield before arguments are resolved if one of the
                     // arguments is an immediate closure, otherwise you cannot step into the
                     // immediate closure
-                    const hasImmediateClosureInNamedArgs = /**@type {SlashCommandExecutor}*/(step.value)?.namedArgumentList?.find(it=>it.value instanceof SlashCommandClosure && it.value.executeNow);
+                    const hasImmediateClosureInNamedArgs = /**@type {SlashCommandExecutor}*/(step.value)?.namedArgumentList?.find(it => it.value instanceof SlashCommandClosure && it.value.executeNow);
-                    const hasImmediateClosureInUnnamedArgs = /**@type {SlashCommandExecutor}*/(step.value)?.unnamedArgumentList?.find(it=>it.value instanceof SlashCommandClosure && it.value.executeNow);
+                    const hasImmediateClosureInUnnamedArgs = /**@type {SlashCommandExecutor}*/(step.value)?.unnamedArgumentList?.find(it => it.value instanceof SlashCommandClosure && it.value.executeNow);
                     if (hasImmediateClosureInNamedArgs || hasImmediateClosureInUnnamedArgs) {
-                        this.debugController.isStepping = yield { closure:this, executor:step.value };
+                        this.debugController.isStepping = yield { closure: this, executor: step.value };
                     } else {
                         this.debugController.isStepping = true;
                         this.debugController.stepStack[this.debugController.stepStack.length - 1] = true;

                 this.debugController.isSteppingInto = false;
                 // if stepping, have to yield before arguments are resolved if one of the arguments
                 // is an immediate closure, otherwise you cannot step into the immediate closure
-                const hasImmediateClosureInNamedArgs = /**@type {SlashCommandExecutor}*/(step.value)?.namedArgumentList?.find(it=>it.value instanceof SlashCommandClosure && it.value.executeNow);
+                const hasImmediateClosureInNamedArgs = /**@type {SlashCommandExecutor}*/(step.value)?.namedArgumentList?.find(it => it.value instanceof SlashCommandClosure && it.value.executeNow);
-                const hasImmediateClosureInUnnamedArgs = /**@type {SlashCommandExecutor}*/(step.value)?.unnamedArgumentList?.find(it=>it.value instanceof SlashCommandClosure && it.value.executeNow);
+                const hasImmediateClosureInUnnamedArgs = /**@type {SlashCommandExecutor}*/(step.value)?.unnamedArgumentList?.find(it => it.value instanceof SlashCommandClosure && it.value.executeNow);
                 if (hasImmediateClosureInNamedArgs || hasImmediateClosureInUnnamedArgs) {
-                    this.debugController.isStepping = yield { closure:this, executor:step.value };
+                    this.debugController.isStepping = yield { closure: this, executor: step.value };
+                }
+            }
             // resolve args

@@ -354,7 +354,7 @@ export class SlashCommandClosure {
354	}	354	}
355	} else if (!step.done && this.debugController?.testStepping(this)) {	355	} else if (!step.done && this.debugController?.testStepping(this)) {
356	this.debugController.isSteppingInto = false;	356	this.debugController.isSteppingInto = false;
357	this.debugController.isStepping = yield { closure:this, executor:step.value };	357	this.debugController.isStepping = yield { closure: this, executor: step.value };
358	}	358	}
359	// execute executor	359	// execute executor
360	step = await stepper.next();	360	step = await stepper.next();

      *  - after arguments are resolved
      *  - after execution
      */
-    async * executeStep() {
+    async* executeStep() {
         let done = 0;
         let isFirst = true;
         for (const executor of this.executorList) {

                 // then yield for "before exec"
                 yield executor;
                 // followed by command execution
-                executor.onProgress = (subDone, subTotal)=>this.onProgress?.(done + subDone, this.commandCount);
+                executor.onProgress = (subDone, subTotal) => this.onProgress?.(done + subDone, this.commandCount);
                 const isStepping = this.debugController?.testStepping(this);
                 if (this.debugController) {
                     this.debugController.isStepping = false || this.debugController.isSteppingInto;

@@ -586,7 +586,7 @@ export class SlashCommandClosure {
586	if (!executor.command.splitUnnamedArgument) {	586	if (!executor.command.splitUnnamedArgument) {
587	if (value.length == 1) {	587	if (value.length == 1) {
588	value = value[0];	588	value = value[0];
589	} else if (!value.find(it=>it instanceof SlashCommandClosure)) {	589	} else if (!value.find(it => it instanceof SlashCommandClosure)) {
590	value = value.join('');	590	value = value.join('');
591	}	591	}
592	}	592	}

                 ?.replace(/\\\}/g, '}')
+            ;
         } else if (Array.isArray(value)) {
-            value = value.map(v=>{
+            value = value.map(v => {
                 if (typeof v == 'string') {
                     return v
                         ?.replace(/\\\{/g, '{')

public/scripts/slash-commands/SlashCommandCommandAutoCompleteOption.js+0 -2 Viewed

@@ -10,8 +10,6 @@ export class SlashCommandCommandAutoCompleteOption extends AutoCompleteOption {
10	}	10	}
11		11
12		12
13
14
15	/**	13	/**
16	* @param {SlashCommand} command	14	* @param {SlashCommand} command
17	* @param {string} name	15	* @param {string} name

public/scripts/slash-commands/SlashCommandCommonEnumsProvider.js+1 -1 Viewed

             ...isAll || types.includes('scope') ? scope.allVariableNames.map(name => new SlashCommandEnumValue(name, null, enumTypes.variable, enumIcons.scopeVariable)) : [],
             ...isAll || types.includes('local') ? Object.keys(chat_metadata.variables ?? []).map(name => new SlashCommandEnumValue(name, null, enumTypes.name, enumIcons.localVariable)) : [],
             ...isAll || types.includes('global') ? Object.keys(extension_settings.variables.global ?? []).map(name => new SlashCommandEnumValue(name, null, enumTypes.macro, enumIcons.globalVariable)) : [],
-        ].filter((item, idx, list)=>idx == list.findIndex(it=>it.value == item.value));
+        ].filter((item, idx, list) => idx == list.findIndex(it => it.value == item.value));
     },
     /**

public/scripts/slash-commands/SlashCommandDebugController.js+4 -9 Viewed

     /** @type {(closure:SlashCommandClosure, executor:SlashCommandExecutor)=>Promise<boolean>} */ onBreakPoint;
     testStepping(closure) {
         return this.stepStack[this.stack.indexOf(closure)];
+    }
     down(closure) {
         this.stack.push(closure);
         if (this.stepStack.length < this.stack.length) {

@@ -44,20 +40,19 @@ export class SlashCommandDebugController {
44	}	40	}
45		41
46		42
47
48	resume() {	43	resume() {
49	this.continueResolver?.(false);	44	this.continueResolver?.(false);
50	this.continuePromise = null;	45	this.continuePromise = null;
51	this.stepStack.forEach((_,idx)=>this.stepStack[idx] = false);	46	this.stepStack.forEach((_, idx) => this.stepStack[idx] = false);
52	}	47	}
53	step() {	48	step() {
54	this.stepStack.forEach((_,idx)=>this.stepStack[idx] = true);	49	this.stepStack.forEach((_, idx) => this.stepStack[idx] = true);
55	this.continueResolver?.(true);	50	this.continueResolver?.(true);
56	this.continuePromise = null;	51	this.continuePromise = null;
57	}	52	}
58	stepInto() {	53	stepInto() {
59	this.isSteppingInto = true;	54	this.isSteppingInto = true;
60	this.stepStack.forEach((_,idx)=>this.stepStack[idx] = true);	55	this.stepStack.forEach((_, idx) => this.stepStack[idx] = true);
61	this.continueResolver?.(true);	56	this.continueResolver?.(true);
62	this.continuePromise = null;	57	this.continuePromise = null;
63	}	58	}

+    }
     async awaitContinue() {
-        this.continuePromise ??= new Promise(resolve=>{
+        this.continuePromise ??= new Promise(resolve => {
             this.continueResolver = resolve;
         });
         this.isStepping = await this.continuePromise;

public/scripts/slash-commands/SlashCommandEnumAutoCompleteOption.js+1 -2 Viewed

      * @returns {SlashCommandEnumAutoCompleteOption}
      */
     static from(cmd, enumValue) {
-        const mapped = this.valueToOptionMap.find(it=>enumValue instanceof it.value)?.option ?? this;
+        const mapped = this.valueToOptionMap.find(it => enumValue instanceof it.value)?.option ?? this;
         return new mapped(cmd, enumValue);
+    }
     /**@type {{value:(typeof SlashCommandEnumValue), option:(typeof SlashCommandEnumAutoCompleteOption)}[]} */

     /**@type {SlashCommandEnumValue}*/ enumValue;
     /**
      * @param {SlashCommand} cmd
      * @param {SlashCommandEnumValue} enumValue

public/scripts/slash-commands/SlashCommandExecutionError.js+0 -1 Viewed

@@ -48,7 +48,6 @@ export class SlashCommandExecutionError extends Error {
48	}	48	}
49		49
50		50
51
52	constructor(cause, message, commandName, start, end, commandText, fullText) {	51	constructor(cause, message, commandName, start, end, commandText, fullText) {
53	super(message, { cause });	52	super(message, { cause });
54	this.commandName = commandName;	53	this.commandName = commandName;

public/scripts/slash-commands/SlashCommandExecutor.js+6 -6 Viewed

@@ -17,10 +17,10 @@ export class SlashCommandExecutor {
17	get source() { return this.#source; }	17	get source() { return this.#source; }
18	set source(value) {	18	set source(value) {
19	this.#source = value;	19	this.#source = value;
20	for (const arg of this.namedArgumentList.filter(it=>it.value instanceof SlashCommandClosure)) {	20	for (const arg of this.namedArgumentList.filter(it => it.value instanceof SlashCommandClosure)) {
21	arg.value.source = value;	21	arg.value.source = value;
22	}	22	}
23	for (const arg of this.unnamedArgumentList.filter(it=>it.value instanceof SlashCommandClosure)) {	23	for (const arg of this.unnamedArgumentList.filter(it => it.value instanceof SlashCommandClosure)) {
24	arg.value.source = value;	24	arg.value.source = value;
25	}	25	}
26	}	26	}

     get commandCount() {
         return 1
-            + this.namedArgumentList.filter(it=>it.value instanceof SlashCommandClosure).map(it=>/**@type {SlashCommandClosure}*/(it.value).commandCount).reduce((cur, sum)=>cur + sum, 0)
+            + this.namedArgumentList.filter(it => it.value instanceof SlashCommandClosure).map(it =>/**@type {SlashCommandClosure}*/(it.value).commandCount).reduce((cur, sum) => cur + sum, 0)
-            + this.unnamedArgumentList.filter(it=>it.value instanceof SlashCommandClosure).map(it=>/**@type {SlashCommandClosure}*/(it.value).commandCount).reduce((cur, sum)=>cur + sum, 0)
+            + this.unnamedArgumentList.filter(it => it.value instanceof SlashCommandClosure).map(it =>/**@type {SlashCommandClosure}*/(it.value).commandCount).reduce((cur, sum) => cur + sum, 0)
+        ;
+    }
     set onProgress(value) {
         const closures = /**@type {SlashCommandClosure[]}*/([
-            ...this.namedArgumentList.filter(it=>it.value instanceof SlashCommandClosure).map(it=>it.value),
+            ...this.namedArgumentList.filter(it => it.value instanceof SlashCommandClosure).map(it => it.value),
-            ...this.unnamedArgumentList.filter(it=>it.value instanceof SlashCommandClosure).map(it=>it.value),
+            ...this.unnamedArgumentList.filter(it => it.value instanceof SlashCommandClosure).map(it => it.value),
         ]);
         for (const closure of closures) {
             closure.onProgress = value;

public/scripts/slash-commands/SlashCommandParser.js+20 -20 Viewed

@@ -65,7 +65,7 @@ export class SlashCommandParser {
65	static addCommandObject(command) {	65	static addCommandObject(command) {
66	const reserved = ['/', '#', ':', 'parser-flag', 'breakpoint'];	66	const reserved = ['/', '#', ':', 'parser-flag', 'breakpoint'];
67	for (const start of reserved) {	67	for (const start of reserved) {
68	if (command.name.toLowerCase().startsWith(start) \|\| (command.aliases ?? []).find(a=>a.toLowerCase().startsWith(start))) {	68	if (command.name.toLowerCase().startsWith(start) \|\| (command.aliases ?? []).find(a => a.toLowerCase().startsWith(start))) {
69	throw new Error(`Illegal Name. Slash command name cannot begin with "${start}".`);	69	throw new Error(`Illegal Name. Slash command name cannot begin with "${start}".`);
70	}	70	}
71	}	71	}

             console.trace('WARN: Duplicate slash command registered!', [command.name, ...command.aliases]);
+        }
-        const stack = new Error().stack.split('\n').map(it=>it.trim());
+        const stack = new Error().stack.split('\n').map(it => it.trim());
-        command.isExtension = stack.find(it=>it.includes('/scripts/extensions/')) != null;
+        command.isExtension = stack.find(it => it.includes('/scripts/extensions/')) != null;
-        command.isThirdParty = stack.find(it=>it.includes('/scripts/extensions/third-party/')) != null;
+        command.isThirdParty = stack.find(it => it.includes('/scripts/extensions/third-party/')) != null;
         if (command.isThirdParty) {
-            command.source = stack.find(it=>it.includes('/scripts/extensions/third-party/')).replace(/^.*?\/scripts\/extensions\/third-party\/([^/]+)\/.*$/, '$1');
+            command.source = stack.find(it => it.includes('/scripts/extensions/third-party/')).replace(/^.*?\/scripts\/extensions\/third-party\/([^/]+)\/.*$/, '$1');
         } else if (command.isExtension) {
-            command.source = stack.find(it=>it.includes('/scripts/extensions/')).replace(/^.*?\/scripts\/extensions\/([^/]+)\/.*$/, '$1');
+            command.source = stack.find(it => it.includes('/scripts/extensions/')).replace(/^.*?\/scripts\/extensions\/([^/]+)\/.*$/, '$1');
         } else {
-            const idx = stack.findLastIndex(it=>it.includes('at SlashCommandParser.')) + 1;
+            const idx = stack.findLastIndex(it => it.includes('at SlashCommandParser.')) + 1;
             command.source = stack[idx].replace(/^.*?\/((?:scripts\/)?(?:[^/]+)\.js).*$/, '$1');
+        }

                         description: 'The parser flag to modify.',
                         typeList: [ARGUMENT_TYPE.STRING],
                         isRequired: true,
-                        enumList: Object.keys(PARSER_FLAG).map(flag=>new SlashCommandEnumValue(flag, help[PARSER_FLAG[flag]])),
+                        enumList: Object.keys(PARSER_FLAG).map(flag => new SlashCommandEnumValue(flag, help[PARSER_FLAG[flag]])),
                     }),
                     SlashCommandArgument.fromProps({
                         description: 'The state of the parser flag to set.',

             PIPEBREAK,
             PIPE,
         );
-        hljs.registerLanguage('stscript', ()=>({
+        hljs.registerLanguage('stscript', () => ({
             case_insensitive: false,
             keywords: [],
             contains: [

             if (executor.name == ':') {
                 const options = this.scopeIndex[this.commandIndex.indexOf(executor)]
                     ?.allVariableNames
-                    ?.map(it=>new SlashCommandVariableAutoCompleteOption(it))
+                    ?.map(it => new SlashCommandVariableAutoCompleteOption(it))
                     ?? []
+                ;
                 try {
                     if ('quickReplyApi' in globalThis) {
                         const qrApi = globalThis.quickReplyApi;
                         options.push(...qrApi.listSets()
-                            .map(set=>qrApi.listQuickReplies(set).map(qr=>`${set}.${qr}`))
+                            .map(set => qrApi.listQuickReplies(set).map(qr => `${set}.${qr}`))
                             .flat()
-                            .map(qr=>new SlashCommandQuickReplyAutoCompleteOption(qr)),
+                            .map(qr => new SlashCommandQuickReplyAutoCompleteOption(qr)),
                         );
+                    }
                 } catch { /* empty */ }

                     executor.start,
                     options,
                     true,
-                    ()=>`No matching variables in scope and no matching Quick Replies for "${result.name}"`,
+                    () => `No matching variables in scope and no matching Quick Replies for "${result.name}"`,
-                    ()=>'No variables in scope and no Quick Replies found.',
+                    () => 'No variables in scope and no Quick Replies found.',
                 );
                 return result;
+            }

         return this.testSymbol(':}');
+    }
     parseClosure(isRoot = false) {
-        const closureIndexEntry = { start:this.index + 1, end:null };
+        const closureIndexEntry = { start: this.index + 1, end: null };
         this.closureIndex.push(closureIndexEntry);
         let injectPipe = true;
         if (!isRoot) this.take(2); // discard opening {:

             cmd.unnamedArgumentList = this.parseUnnamedArgument(cmd.command?.unnamedArgumentList?.length && cmd?.command?.splitUnnamedArgument, cmd?.command?.splitUnnamedArgumentCount, rawQuotes);
             cmd.endUnnamedArgs = this.index;
             if (cmd.name == 'let') {
-                const keyArg = cmd.namedArgumentList.find(it=>it.name == 'key');
+                const keyArg = cmd.namedArgumentList.find(it => it.name == 'key');
                 if (keyArg) {
                     this.scope.variableNames.push(keyArg.value.toString());
                 } else if (typeof cmd.unnamedArgumentList[0]?.value == 'string') {
                     this.scope.variableNames.push(cmd.unnamedArgumentList[0].value);
+                }
             } else if (cmd.name == 'import') {
-                const value = /**@type {string[]}*/(cmd.unnamedArgumentList.map(it=>it.value));
+                const value = /**@type {string[]}*/(cmd.unnamedArgumentList.map(it => it.value));
                 for (let i = 0; i < value.length; i++) {
                     const srcName = value[i];
                     let dstName = srcName;

public/scripts/slash-commands/SlashCommandScope.js+3 -5 Viewed

     /** @type {string[]} */ variableNames = [];
     get allVariableNames() {
         const names = [...this.variableNames, ...(this.parent?.allVariableNames ?? [])];
-        return names.filter((it,idx)=>idx == names.indexOf(it));
+        return names.filter((it, idx) => idx == names.indexOf(it));
+    }
     // @ts-ignore
     /** @type {object.<string, string|SlashCommandClosure>} */ variables = {};

     /** @type {object.<string, string|SlashCommandClosure>} */ macros = {};
     /** @type {{key:string, value:string|SlashCommandClosure}[]} */
     get macroList() {
-        return [...Object.keys(this.macros).map(key=>({ key, value:this.macros[key] })), ...(this.parent?.macroList ?? [])];
+        return [...Object.keys(this.macros).map(key => ({ key, value: this.macros[key] })), ...(this.parent?.macroList ?? [])];
+    }
     /** @type {SlashCommandScope} */ parent;
     /** @type {string} */ #pipe;

@@ -40,7 +40,7 @@ export class SlashCommandScope {
40		40
41		41
42	setMacro(key, value, overwrite = true) {	42	setMacro(key, value, overwrite = true) {
43	if (overwrite \|\| !this.macroList.find(it=>it.key == key)) {	43	if (overwrite \|\| !this.macroList.find(it => it.key == key)) {
44	this.macros[key] = value;	44	this.macros[key] = value;
45	}	45	}
46	}	46	}

@@ -109,8 +109,6 @@ export class SlashCommandScope {
109	}	109	}
110		110
111		111
112
113
114	export class SlashCommandScopeVariableExistsError extends Error {}	112	export class SlashCommandScopeVariableExistsError extends Error {}
115		113
116		114

public/scripts/tags.js+0 -1 Viewed

     // If folder display has changed, we have to redraw the character list, otherwise this folders state would not change
     printCharactersDebounced();
     saveSettingsDebounced();
+}
 function updateDrawTagFolder(element, tag) {

public/scripts/textgen-settings.js+2 -3 Viewed

@@ -802,7 +802,6 @@ async function getStatusTextgen() {
802	console.info('Status check aborted.', err.reason);	802	console.info('Status check aborted.', err.reason);
803	} else {	803	} else {
804	console.error('Error getting status', err);	804	console.error('Error getting status', err);
805
806	}	805	}
807	setOnlineStatus('no_connection');	806	setOnlineStatus('no_connection');
808	}	807	}

  * @returns void
  */
 function showSamplerControls(apiType = null) {
-    $('#textgenerationwebui_api-settings [data-tg-samplers], #textgenerationwebui_api [data-tg-samplers]').each(function(idx, elem) {
+    $('#textgenerationwebui_api-settings [data-tg-samplers], #textgenerationwebui_api [data-tg-samplers]').each(function (idx, elem) {
         const typeSpecificControlled = $(elem).data('tg-type') !== undefined;
         if (!typeSpecificControlled) $(this).show();

     if (!samplersActivatedManually?.length || !prioritizeManualSamplerSelect) return;
-    $('#textgenerationwebui_api-settings [data-tg-samplers], #textgenerationwebui_api [data-tg-samplers]').each(function() {
+    $('#textgenerationwebui_api-settings [data-tg-samplers], #textgenerationwebui_api [data-tg-samplers]').each(function () {
         const tgSamplers = $(this).attr('data-tg-samplers').split(',').map(x => x.trim()).filter(str => str !== '');
         for (const tgSampler of tgSamplers) {

public/scripts/user.js+0 -4 Viewed

         toastr.success('Name changed successfully', 'Name Changed');
         callback();
     } catch (error) {
         console.error('Error changing name:', error);
+    }

@@ -495,7 +494,6 @@ async function restoreSnapshot(name, callback) {
495	} catch (error) {	494	} catch (error) {
496	console.error('Error restoring snapshot:', error);	495	console.error('Error restoring snapshot:', error);
497	}	496	}
498
499	}	497	}
500		498
501	/**	499	/**

@@ -601,7 +599,6 @@ async function viewSettingsSnapshots() {
601	const content = await loadSnapshotContent(snapshot.name);	599	const content = await loadSnapshotContent(snapshot.name);
602	contentBlock.val(content);	600	contentBlock.val(content);
603	}	601	}
604
605	});	602	});
606	template.find('.snapshotList').append(snapshotBlock);	603	template.find('.snapshotList').append(snapshotBlock);
607	}	604	}

@@ -667,7 +664,6 @@ async function resetEverything(callback) {
667	} catch (error) {	664	} catch (error) {
668	console.error('Error resetting everything:', error);	665	console.error('Error resetting everything:', error);
669	}	666	}
670
671	}	667	}
672		668
673	async function openUserProfile() {	669	async function openUserProfile() {

public/scripts/utils.js+0 -1 Viewed

                 flags: new RegExp('(?<=\\/)([gimsuy]*)$', 'g'),  // Match trailing flags
                 delimiters: new RegExp('^\\/|(?<![\\\\<])\\/', 'g'),  // Match leading or trailing delimiters
             };
         } catch (error) {
             return {
                 brackets: new RegExp('(\\\\)?\\[.*?\\]', 'g'),  // Non-escaped square brackets

public/scripts/world-info.js+0 -2 Viewed

@@ -675,7 +675,6 @@ class WorldInfoTimedEffects {
675	console.log('[WI] Timed effect "delay" applied to entry', entry);	675	console.log('[WI] Timed effect "delay" applied to entry', entry);
676	}	676	}
677	}	677	}
678
679	}	678	}
680		679
681	/**	680	/**

@@ -4495,7 +4494,6 @@ function parseDecorators(content) {
4495	}	4494	}
4496		4495
4497	return [[], content];	4496	return [[], content];
4498
4499	}	4497	}
4500		4498
4501	/**	4499	/**

src/endpoints/assets.js+0 -2 Viewed

     try {
         if (fs.existsSync(folderPath) && fs.statSync(folderPath).isDirectory()) {
             ensureFoldersExist(request.user.directories);
             const folders = fs.readdirSync(folderPath, { withFileTypes: true })

     let output = [];
     try {
         if (fs.existsSync(folderPath) && fs.statSync(folderPath).isDirectory()) {
             // Live2d assets
             if (category == 'live2d') {
                 const folders = fs.readdirSync(folderPath, { withFileTypes: true });

src/endpoints/backends/text-completions.js+0 -2 Viewed

         console.debug('LlamaCpp props response:', data);
         return response.send(data);
     } catch (error) {
         console.error(error);
         return response.sendStatus(500);

         console.debug('LlamaCpp slots response:', data);
         return response.send(data);
     } catch (error) {
         console.error(error);
         return response.sendStatus(500);

src/endpoints/backups.js+1 -1 Viewed

         const backupModels = [];
         const backupFiles = await fsPromises
             .readdir(request.user.directories.backups, { withFileTypes: true })
-            .then(d => d .filter(d => d.isFile() && path.extname(d.name) === '.jsonl' && d.name.startsWith(CHAT_BACKUPS_PREFIX)).map(d => d.name));
+            .then(d => d.filter(d => d.isFile() && path.extname(d.name) === '.jsonl' && d.name.startsWith(CHAT_BACKUPS_PREFIX)).map(d => d.name));
         for (const name of backupFiles) {
             const filePath = path.join(request.user.directories.backups, name);

src/endpoints/characters.js+2 -2 Viewed

@@ -639,7 +639,6 @@ function charaFormatData(data, directories) {
639	if (file && file.entries) {	639	if (file && file.entries) {
640	_.set(char, 'data.character_book', convertWorldInfoToCharacterBook(data.world, file.entries));	640	_.set(char, 'data.character_book', convertWorldInfoToCharacterBook(data.world, file.entries));
641	}	641	}
642
643	} catch {	642	} catch {
644	console.warn(`Failed to read world info file: ${data.world}. Character book will not be available.`);	643	console.warn(`Failed to read world info file: ${data.world}. Character book will not be available.`);
645	}	644	}

         let charJSON = JSON.stringify(char);
         const result = await writeCharacterData(DEFAULT_AVATAR_PATH, charJSON, pngName, request);
         return result ? pngName : '';
-    } else if (jsonData.char_name !== undefined) {//json Pygmalion notepad
+    } else if (jsonData.char_name !== undefined) {
+        //json Pygmalion notepad
         console.info('Importing from gradio json');
         jsonData.char_name = sanitize(jsonData.char_name);
         if (jsonData.creator_notes) {

src/endpoints/extensions.js+0 -2 Viewed

         const { isUpToDate, remoteUrl } = await checkIfRepoIsUpToDate(extensionPath);
         return response.send({ currentBranchName, currentCommitHash, isUpToDate, remoteUrl });
     } catch (error) {
         console.error('Getting extension version failed', error);
         return response.status(500).send(`Server Error: ${error.message}`);

         console.info(`Extension has been deleted at ${extensionPath}`);
         return response.send(`Extension has been deleted at ${extensionPath}`);
     } catch (error) {
         console.error('Deleting custom content failed', error);
         return response.status(500).send(`Server Error: ${error.message}`);

src/endpoints/groups.js+1 -1 Viewed

@@ -51,7 +51,7 @@ export async function migrateGroupChatsMetadataFormat(userDirectories) {
51	if (!needsMigration) {	51	if (!needsMigration) {
52	continue;	52	continue;
53	}	53	}
54	if (!fs.existsSync(backupPath)){	54	if (!fs.existsSync(backupPath)) {
55	await fsPromises.mkdir(backupPath, { recursive: true });	55	await fsPromises.mkdir(backupPath, { recursive: true });
56	}	56	}
57	await fsPromises.copyFile(groupFilePath, path.join(backupPath, groupFile.name));	57	await fsPromises.copyFile(groupFilePath, path.join(backupPath, groupFile.name));

src/endpoints/horde.js+0 -2 Viewed

             console.info(status);
             if (status.state === HordeAsyncRequestStates.done) {
                 if (status.forms === undefined) {
                     console.error('Image interrogation request failed: no forms found.');
                     return response.sendStatus(500);

@@ -278,7 +277,6 @@ router.post('/caption-image', async (request, response) => {
278	return response.sendStatus(503);	277	return response.sendStatus(503);
279	}	278	}
280	}	279	}
281
282	} catch (error) {	280	} catch (error) {
283	console.error(error);	281	console.error(error);
284	response.sendStatus(500);	282	response.sendStatus(500);

src/endpoints/image-metadata.js+0 -1 Viewed

+        }
         return response.status(400).json({ error: 'Invalid request format.' });
     } catch (error) {
         console.error('[ImageMetadata] API error:', error);
         return response.status(500).json({ error: 'Internal server error.' });

src/endpoints/minimax.js+0 -2 Viewed

                 response.setHeader('Content-Length', audioBytes.length);
                 return response.send(Buffer.from(audioBytes));
             } catch (conversionError) {
                 console.error('MiniMax TTS: Audio conversion error:', conversionError);
                 return response.status(500).json({ error: `Audio data conversion failed: ${conversionError.message}` });

             console.error('MiniMax TTS: No valid audio data in response:', responseData);
             return response.status(500).json({ error: `API Error: ${errorMessage}` });
+        }
     } catch (error) {
         console.error('MiniMax TTS generation failed:', error);
         return response.status(500).json({ error: 'Internal server error' });

src/endpoints/stable-diffusion.js+0 -1 Viewed

         const data = await result.json();
         const names = data.map(x => x.name);
         return response.send(names);
     } catch (error) {
         console.error(error);
         return response.sendStatus(500);

src/endpoints/thumbnails.js+0 -1 Viewed

         // Send a 404 so the frontend can display a placeholder
         return response.sendStatus(404);
     } catch (error) {
         console.error('Failed getting thumbnail', error);
         return response.sendStatus(500);

src/prompt-converters.js+1 -2 Viewed

  * @copyright Prompt Conversion script taken from RisuAI by kwaroran (GPLv3).
  */
 export function convertClaudePrompt(messages, addAssistantPostfix, addAssistantPrefill, withSysPromptSupport, useSystemPrompt, addSysHumanMsg, excludePrefixes) {
     //Prepare messages for claude.
     //When 'Exclude Human/Assistant prefixes' checked, setting messages role to the 'system'(last message is exception).
     if (messages.length > 0) {

@@ -1278,7 +1277,7 @@ export function calculateGoogleBudgetTokens(maxTokens, reasoningEffort, model) {
1278	return getGemini3ProBudget();	1277	return getGemini3ProBudget();
1279	}	1278	}
1280		1279
1281	if (/gemini-3-flash/.test(model) ) {	1280	if (/gemini-3-flash/.test(model)) {
1282	return getGemini3FlashBudget();	1281	return getGemini3FlashBudget();
1283	}	1282	}
1284		1283

src/util.js+0 -1 Viewed

@@ -1012,7 +1012,6 @@ export async function canResolve(name, useIPv6 = true, useIPv4 = true) {
1012	}	1012	}
1013		1013
1014	return v6Resolved \|\| v4Resolved;	1014	return v6Resolved \|\| v4Resolved;
1015
1016	} catch (error) {	1015	} catch (error) {
1017	return false;	1016	return false;
1018	}	1017	}

@@ -480,19 +480,19 @@ export class SlashCommandParser {
480	}	480	}
481	}	481	}
482	const executor = this.commandIndex	482	const executor = this.commandIndex
483	.filter(it=>it.start <= index && (it.end >= index \|\| it.end == null))	483	.filter(it => it.start <= index && (it.end >= index \|\| it.end == null))
484	.slice(-1)[0]	484	.slice(-1)[0]
485	?? null	485	?? null
486	;	486	;
487		487
488	if (executor) {	488	if (executor) {
489	const childClosure = this.closureIndex	489	const childClosure = this.closureIndex
490	.find(it=>it.start <= index && (it.end >= index \|\| it.end == null) && it.start > executor.start)	490	.find(it => it.start <= index && (it.end >= index \|\| it.end == null) && it.start > executor.start)
491	?? null	491	?? null
492	;	492	;
493	if (childClosure !== null) return null;	493	if (childClosure !== null) return null;
494	// Check if cursor is inside a macro	494	// Check if cursor is inside a macro
495	const macroEntry = this.macroIndex.findLast(it=>it.start <= index && it.end >= index);	495	const macroEntry = this.macroIndex.findLast(it => it.start <= index && it.end >= index);
496	if (macroEntry) {	496	if (macroEntry) {
497	// Build macro info object for shared function	497	// Build macro info object for shared function
498	const macroContent = text.slice(macroEntry.start + 2, macroEntry.end - (text.slice(macroEntry.end - 2, macroEntry.end) === '}}' ? 2 : 0));	498	const macroContent = text.slice(macroEntry.start + 2, macroEntry.end - (text.slice(macroEntry.end - 2, macroEntry.end) === '}}' ? 2 : 0));

Chore: Add code formatting conventions as eslint rules (#5158) * Add code formatting conventions as eslint rules * Improve formatting in addQuickReply