Merge branch 'staging' into patch-2

392c98455ec3feeb78ef4ec48ef0243de77ebecb

Cohee <18619528+Cohee1207@users.noreply.github.com>

Parents: 7ac7398568c0c1c6fcf8e708f5a8eaf9feeb5c04 c42df886c57f3df66430819ecd40f3ce0ab76086

public/index.html+37 -35 Viewed

                         </div>
                     </div>
                     <div id="InstructSettingsColumn" class="flex-container flexNoGap flexFlowColumn flex1">
+                        <h4 class="standoutHeader title_restorable justifySpaceBetween">
+                            <div class="flex-container">
+                                <span data-i18n="Instruct Template">Instruct Template</span>
+                                <a href="https://docs.sillytavern.app/usage/core-concepts/instructmode/" class="notes-link" target="_blank">
+                                    <span class="fa-solid fa-circle-question note-link-span"></span>
+                                </a>
+                            </div>
+                            <div class="flex-container">
+                                <label for="instruct_bind_to_context" class="checkbox_label flex1" title="Bind to Context&#10If enabled, Context templates will be automatically selected based on selected Instruct template name or by preference." data-i18n="[title]instruct_bind_to_context">
+                                    <input id="instruct_bind_to_context" type="checkbox" style="display:none;" />
+                                    <small><i class="fa-solid fa-link menu_button margin0"></i></small>
+                                </label>
+                                <label id="instruct_enabled_label"for="instruct_enabled" class="checkbox_label flex1" title="Enable Instruct Mode" data-i18n="[title]instruct_enabled">
+                                    <input id="instruct_enabled" type="checkbox" style="display:none;" />
+                                    <small><i class="fa-solid fa-power-off menu_button margin0"></i></small>
+                                </label>
+                            </div>
+                        </h4>
                         <div id="instructSettingsBlock">
-                            <h4 class="standoutHeader title_restorable justifySpaceBetween">
-                                <div class="flex-container">
-                                    <span data-i18n="Instruct Template">Instruct Template</span>
-                                    <a href="https://docs.sillytavern.app/usage/core-concepts/instructmode/" class="notes-link" target="_blank">
-                                        <span class="fa-solid fa-circle-question note-link-span"></span>
-                                    </a>
-                                </div>
-                                <div class="flex-container">
-                                    <label for="instruct_bind_to_context" class="checkbox_label flex1" title="Bind to Context&#10If enabled, Context templates will be automatically selected based on selected Instruct template name or by preference." data-i18n="[title]instruct_bind_to_context">
-                                        <input id="instruct_bind_to_context" type="checkbox" style="display:none;" />
-                                        <small><i class="fa-solid fa-link menu_button margin0"></i></small>
-                                    </label>
-                                    <label for="instruct_enabled" class="checkbox_label flex1" title="Enable Instruct Mode" data-i18n="[title]instruct_enabled">
-                                        <input id="instruct_enabled" type="checkbox" style="display:none;" />
-                                        <small><i class="fa-solid fa-power-off menu_button margin0"></i></small>
-                                    </label>
-                                </div>
-                            </h4>
                             <div class="flex-container" title="Select your current Instruct Template" data-i18n="[title]Select your current Instruct Template">
                                 <select id="instruct_presets" data-preset-manager-for="instruct" class="flex1 text_pole"></select>

                         </div>
                     </div>
                     <div id="SystemPromptColumn" class="flex-container flexNoGap flexFlowColumn flex1">
+                        <h4 class="standoutHeader title_restorable justifySpaceBetween">
+                            <div class="flex-container">
+                                <span data-i18n="System Prompt">System Prompt</span>
+                                <a href="https://docs.sillytavern.app/usage/core-concepts/advancedformatting/#system-prompt" class="notes-link" target="_blank">
+                                    <span class="fa-solid fa-circle-question note-link-span"></span>
+                                </a>
+                            </div>
+                            <div class="flex-container">
+                                <label id="sysprompt_enabled_label" for="sysprompt_enabled" class="checkbox_label flex1" title="Enable System Prompt" data-i18n="[title]sysprompt_enabled">
+                                    <input id="sysprompt_enabled" type="checkbox" style="display:none;" />
+                                    <small><i class="fa-solid fa-power-off menu_button margin0"></i></small>
+                                </label>
+                            </div>
+                        </h4>
                         <div id="SystemPromptBlock">
-                            <h4 class="standoutHeader title_restorable justifySpaceBetween">
-                                <div class="flex-container">
-                                    <span data-i18n="System Prompt">System Prompt</span>
-                                    <a href="https://docs.sillytavern.app/usage/core-concepts/advancedformatting/#system-prompt" class="notes-link" target="_blank">
-                                        <span class="fa-solid fa-circle-question note-link-span"></span>
-                                    </a>
-                                </div>
-                                <div class="flex-container">
-                                    <label for="sysprompt_enabled" class="checkbox_label flex1" title="Enable System Prompt" data-i18n="[title]sysprompt_enabled">
-                                        <input id="sysprompt_enabled" type="checkbox" style="display:none;" />
-                                        <small><i class="fa-solid fa-power-off menu_button margin0"></i></small>
-                                    </label>
-                                </div>
-                            </h4>
                             <div class="flex-container" title="Select your current System Prompt" data-i18n="[title]Select your current System Prompt">
                                 <select id="sysprompt_select" data-preset-manager-for="sysprompt" class="flex1 text_pole"></select>

                     </div>
                     <div class="mes_bias"></div>
                 </div>
-                <div class="swipe_right fa-solid fa-chevron-right" style="display: none;">
+                    <div class="swipe_right fa-solid fa-chevron-right" style="display: none;">
-                    <div class="swipes-counter"></div>
+                        <div class="swipes-counter"></div>
-                </div>
+                    </div>
             </div>
         </div>
         <div id="group_avatars_template" class="template_element">

public/script.js+14 -2 Viewed

 import { currentUser, setUserControls } from './scripts/user.js';
 import { POPUP_RESULT, POPUP_TYPE, Popup, callGenericPopup, fixToastrForDialogs } from './scripts/popup.js';
 import { renderTemplate, renderTemplateAsync } from './scripts/templates.js';
-import { ScraperManager } from './scripts/scrapers.js';
+import { initScrapers, ScraperManager } from './scripts/scrapers.js';
 import { SlashCommandParser } from './scripts/slash-commands/SlashCommandParser.js';
 import { SlashCommand } from './scripts/slash-commands/SlashCommand.js';
 import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from './scripts/slash-commands/SlashCommandArgument.js';

     initCfg();
     initLogprobs();
     initInputMarkdown();
+    await initScrapers();
     doDailyExtensionUpdatesCheck();
     await hideLoader();
     await fixViewport();

         getMessage = getMessage.substring(0, getMessage.indexOf('<|endoftext|>'));
+    }
     const isInstruct = power_user.instruct.enabled && main_api !== 'openai';
+    const isNotEmpty = (str) => str && str.trim() !== '';
     if (isInstruct && power_user.instruct.stop_sequence) {
         if (getMessage.indexOf(power_user.instruct.stop_sequence) != -1) {
             getMessage = getMessage.substring(0, getMessage.indexOf(power_user.instruct.stop_sequence));

@@ -5434,7 +5436,7 @@ export function cleanUpMessage(getMessage, isImpersonate, isContinue, displayInc
5434	}	5436	}
5435	// Hana: Only use the first sequence (should be <\|model\|>)	5437	// Hana: Only use the first sequence (should be <\|model\|>)
5436	// of the prompt before <\|user\|> (as KoboldAI Lite does it).	5438	// of the prompt before <\|user\|> (as KoboldAI Lite does it).
5437	if (isInstruct && power_user.instruct.input_sequence) {	5439	if (isInstruct && isNotEmpty(power_user.instruct.input_sequence)) {
5438	if (getMessage.indexOf(power_user.instruct.input_sequence) != -1) {	5440	if (getMessage.indexOf(power_user.instruct.input_sequence) != -1) {
5439	getMessage = getMessage.substring(0, getMessage.indexOf(power_user.instruct.input_sequence));	5441	getMessage = getMessage.substring(0, getMessage.indexOf(power_user.instruct.input_sequence));
5440	}	5442	}

         selected: 'novel',
         button: '#api_button_novel',
     },
+    'koboldcpp': {
+        selected: 'textgenerationwebui',
+        button: '#api_button_textgenerationwebui',
+        type: textgen_types.KOBOLDCPP,
+    },
     // KoboldCpp alias
     'kcpp': {
         selected: 'textgenerationwebui',
         button: '#api_button_textgenerationwebui',
         type: textgen_types.KOBOLDCPP,
     },
+    'openai': {
+        selected: 'openai',
+        button: '#api_button_openai',
+        source: chat_completion_sources.OPENAI,
+    },
     // OpenAI alias
     'oai': {
         selected: 'openai',

public/scripts/RossAscends-mods.js+17 -16 Viewed

 const observerConfig = { childList: true, subtree: true };
 const countTokensDebounced = debounce(RA_CountCharTokens, debounce_timeout.relaxed);
+const countTokensShortDebounced = debounce(RA_CountCharTokens, debounce_timeout.short);
+const checkStatusDebounced = debounce(RA_checkOnlineStatus, debounce_timeout.short);
 const observer = new MutationObserver(function (mutations) {
     mutations.forEach(function (mutation) {
+        if (!(mutation.target instanceof HTMLElement)) {
+            return;
+        }
         if (mutation.target.classList.contains('online_status_text')) {
-            RA_checkOnlineStatus();
+            checkStatusDebounced();
         } else if (mutation.target.parentNode === SelectedCharacterTab) {
-            setTimeout(RA_CountCharTokens, 200);
+            countTokensShortDebounced();
         } else if (mutation.target.classList.contains('mes_text')) {
-            if (mutation.target instanceof HTMLElement) {
+            for (const element of mutation.target.getElementsByTagName('math')) {
-                for (const element of mutation.target.getElementsByTagName('math')) {
+                element.childNodes.forEach(function (child) {
-                    element.childNodes.forEach(function (child) {
+                    if (child.nodeType === Node.TEXT_NODE) {
-                        if (child.nodeType === Node.TEXT_NODE) {
+                        child.textContent = '';
-                            child.textContent = '';
+                    }
-                        }
+                });
-                    });
-                }
+            }
+        }
     });

 export function humanizedDateTime() {
     const now = new Date(Date.now());
     const dt = {
-        year: now.getFullYear(),  month: now.getMonth() + 1,  day: now.getDate(),
+        year: now.getFullYear(), month: now.getMonth() + 1, day: now.getDate(),
-        hour: now.getHours(),     minute: now.getMinutes(),   second: now.getSeconds(),
+        hour: now.getHours(), minute: now.getMinutes(), second: now.getSeconds(),
     };
     for (const key in dt) {
         dt[key] = dt[key].toString().padStart(2, '0');

 export function initRossMods() {
     // initial status check
-    setTimeout(() => {
+    checkStatusDebounced();
-        RA_checkOnlineStatus();
-    }, 100);
     if (power_user.auto_load_chat) {
         RA_autoloadchat();

         setTimeout(() => RA_autoconnect(PrevAPI), 100);
     });
-    $('#api_button').click(function () { setTimeout(RA_checkOnlineStatus, 100); });
+    $('#api_button').on('click', () => checkStatusDebounced());
     //toggle pin class when lock toggle clicked
     $(RPanelPin).on('click', function () {

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

 import { dragElement, isMobile } from '../../RossAscends-mods.js';
 import { getContext, getApiUrl, modules, extension_settings, ModuleWorkerWrapper, doExtrasFetch, renderExtensionTemplateAsync } from '../../extensions.js';
 import { loadMovingUIState, power_user } from '../../power-user.js';
-import { onlyUnique, debounce, getCharaFilename, trimToEndSentence, trimToStartSentence, waitUntilCondition } from '../../utils.js';
+import { onlyUnique, debounce, getCharaFilename, trimToEndSentence, trimToStartSentence, waitUntilCondition, findChar } from '../../utils.js';
 import { hideMutedSprites } from '../../group-chats.js';
 import { isJsonSchemaSupported } from '../../textgen-settings.js';
 import { debounce_timeout } from '../../constants.js';

     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'lastsprite',
-        callback: (_, value) => lastExpression[String(value).trim()] ?? '',
+        callback: (_, name) => {
+            if (typeof name !== 'string') throw new Error('name must be a string');
+            const char = findChar({ name: name });
+            const sprite = lastExpression[char?.name ?? name] ?? '';
+            return sprite;
+        },
         returns: 'the last set sprite / expression for the named character.',
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'character name',
+                description: 'Character name - or unique character identifier (avatar key)',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 enumProvider: commonEnumProviders.characters('character'),
+                forceEnum: true,
             }),
         ],
         helpString: 'Returns the last set sprite / expression for the named character.',

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

             description: 'character name',
             typeList: [ARGUMENT_TYPE.STRING],
             enumProvider: commonEnumProviders.characters('character'),
+            forceEnum: true,
         }),
         SlashCommandNamedArgument.fromProps({
             name: 'group',

public/scripts/scrapers.js+16 -7 Viewed

  * @property {string} description
  * @property {string} iconClass
  * @property {boolean} iconAvailable
+ * @property {() => Promise<void>} [init=null]
  * @property {() => Promise<boolean>} isAvailable
  * @property {() => Promise<File[]>} scrape
  */

      * Register a scraper to be used by the Data Bank.
      * @param {Scraper} scraper Instance of a scraper to register
      */
-    static registerDataBankScraper(scraper) {
+    static async registerDataBankScraper(scraper) {
         if (ScraperManager.#scrapers.some(s => s.id === scraper.id)) {
             console.warn(`Scraper with ID ${scraper.id} already registered`);
             return;
+        }
+        if (scraper.init) {
+            await scraper.init();
+        }
         ScraperManager.#scrapers.push(scraper);
+    }

         this.description = 'Download a transcript from a YouTube video.';
         this.iconClass = 'fa-brands fa-youtube';
         this.iconAvailable = true;
+    }
+    async init() {
         SlashCommandParser.addCommandObject(SlashCommand.fromProps({
             name: 'yt-script',
             callback: async (args, url) => {

+    }
+}
-ScraperManager.registerDataBankScraper(new FileScraper());
+export async function initScrapers() {
-ScraperManager.registerDataBankScraper(new Notepad());
+    await ScraperManager.registerDataBankScraper(new FileScraper());
-ScraperManager.registerDataBankScraper(new WebScraper());
+    await ScraperManager.registerDataBankScraper(new Notepad());
-ScraperManager.registerDataBankScraper(new MediaWikiScraper());
+    await ScraperManager.registerDataBankScraper(new WebScraper());
-ScraperManager.registerDataBankScraper(new FandomScraper());
+    await ScraperManager.registerDataBankScraper(new MediaWikiScraper());
-ScraperManager.registerDataBankScraper(new YouTubeScraper());
+    await ScraperManager.registerDataBankScraper(new FandomScraper());
+    await ScraperManager.registerDataBankScraper(new YouTubeScraper());
+}

public/scripts/slash-commands.js+225 -108 Viewed

 import { addEphemeralStoppingString, chat_styles, flushEphemeralStoppingStrings, power_user } from './power-user.js';
 import { SERVER_INPUTS, textgen_types, textgenerationwebui_settings } from './textgen-settings.js';
 import { decodeTextTokens, getAvailableTokenizers, getFriendlyTokenizerName, getTextTokens, getTokenCountAsync, selectTokenizer } from './tokenizers.js';
-import { debounce, delay, isFalseBoolean, isTrueBoolean, showFontAwesomePicker, stringToRange, trimToEndSentence, trimToStartSentence, waitUntilCondition } from './utils.js';
+import { debounce, delay, equalsIgnoreCaseAndAccents, findChar, getCharIndex, isFalseBoolean, isTrueBoolean, showFontAwesomePicker, stringToRange, trimToEndSentence, trimToStartSentence, waitUntilCondition } from './utils.js';
 import { registerVariableCommands, resolveVariable } from './variables.js';
 import { background_settings } from './backgrounds.js';
 import { SlashCommandClosure } from './slash-commands/SlashCommandClosure.js';

 import { SlashCommandEnumValue, enumTypes } from './slash-commands/SlashCommandEnumValue.js';
 import { POPUP_TYPE, Popup, callGenericPopup } from './popup.js';
 import { commonEnumProviders, enumIcons } from './slash-commands/SlashCommandCommonEnumsProvider.js';
-import { SlashCommandDebugController } from './slash-commands/SlashCommandDebugController.js';
 import { SlashCommandBreakController } from './slash-commands/SlashCommandBreakController.js';
 import { SlashCommandExecutionError } from './slash-commands/SlashCommandExecutionError.js';
 export {

     `,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'char-find',
+        aliases: ['findchar'],
+        callback: (args, name) => {
+            if (typeof name !== 'string') throw new Error('name must be a string');
+            if (args.preferCurrent instanceof SlashCommandClosure || Array.isArray(args.preferCurrent)) throw new Error('preferCurrent cannot be a closure or array');
+            if (args.quiet instanceof SlashCommandClosure || Array.isArray(args.quiet)) throw new Error('quiet cannot be a closure or array');
+            const char = findChar({ name: name, filteredByTags: validateArrayArgString(args.tag, 'tag'), preferCurrentChar: !isFalseBoolean(args.preferCurrent), quiet: isTrueBoolean(args.quiet) });
+            return char?.avatar ?? '';
+        },
+        returns: 'the avatar key (unique identifier) of the character',
+        namedArgumentList: [
+            SlashCommandNamedArgument.fromProps({
+                name: 'tag',
+                description: 'Supply one or more tags to filter down to the correct character for the provided name, if multiple characters have the same name.',
+                typeList: [ARGUMENT_TYPE.STRING],
+                enumProvider: commonEnumProviders.tags('assigned'),
+                acceptsMultiple: true,
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'preferCurrent',
+                description: 'Prefer current character or characters in a group, if multiple characters match',
+                typeList: [ARGUMENT_TYPE.BOOLEAN],
+                defaultValue: 'true',
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'quiet',
+                description: 'Do not show warning if multiple charactrers are found',
+                typeList: [ARGUMENT_TYPE.BOOLEAN],
+                defaultValue: 'false',
+                enumProvider: commonEnumProviders.boolean('trueFalse'),
+            }),
+        ],
+        unnamedArgumentList: [
+            SlashCommandArgument.fromProps({
+                description: 'Character name - or unique character identifier (avatar key)',
+                typeList: [ARGUMENT_TYPE.STRING],
+                enumProvider: commonEnumProviders.characters('character'),
+                forceEnum: false,
+            }),
+        ],
+        helpString: `
+        <div>
+            Searches for a character and returns its avatar key.
+        </div>
+        <div>
+            This can be used to choose the correct character for something like <code>/sendas</code> or other commands in need of a character name
+            if you have multiple characters with the same name.
+        </div>
+        <div>
+            <strong>Example:</strong>
+            <ul>
+                <li>
+                    <pre><code>/char-find name="Chloe"</code></pre>
+                    Returns the avatar key for "Chloe".
+                </li>
+                <li>
+                    <pre><code>/search name="Chloe" tag="friend"</code></pre>
+                    Returns the avatar key for the character "Chloe" that is tagged with "friend".
+                    This is useful if you for example have multiple characters named "Chloe", and the others are "foe", "goddess", or anything else,
+                    so you can actually select the character you are looking for.
+                </li>
+            </ul>
+        </div>
+        `,
+    }));
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'sendas',
         callback: sendMessageAs,
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'name',
-                description: 'Character name',
+                description: 'Character name - or unique character identifier (avatar key)',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 enumProvider: commonEnumProviders.characters('character'),
                 forceEnum: false,
             }),
-            new SlashCommandNamedArgument(
+            SlashCommandNamedArgument.fromProps({
-                'compact', 'Use compact layout', [ARGUMENT_TYPE.BOOLEAN], false, false, 'false',
+                name: 'avatar',
-            ),
+                description: 'Character avatar override (Can be either avatar key or just the character name to pull the avatar from)',
+                typeList: [ARGUMENT_TYPE.STRING],
+                enumProvider: commonEnumProviders.characters('character'),
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'compact',
+                description: 'Use compact layout',
+                typeList: [ARGUMENT_TYPE.BOOLEAN],
+                defaultValue: 'false',
+            }),
             SlashCommandNamedArgument.fromProps({
                 name: 'at',
                 description: 'position to insert the message (index-based, corresponding to message id). If not set, the message will be inserted at the end of the chat.\nNegative values are accepted and will work similarly to how \'depth\' usually works. For example, -1 will insert the message right before the last message in chat.',

                     <pre><code>/sendas name="Chloe" Hello, guys!</code></pre>
                     will send "Hello, guys!" from "Chloe".
                 </li>
+                <li>
+                    <pre><code>/sendas name="Chloe" avatar="BigBadBoss" Hehehe, I am the big bad evil, fear me.</code></pre>
+                    will send a message as the character "Chloe", but utilizing the avatar from a character named "BigBadBoss".
+                </li>
             </ul>
         </div>
         <div>

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'go',
         callback: goToCharacterCallback,
+        returns: 'The character/group name',
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'name',
+                description: 'Character name - or unique character identifier (avatar key)',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 enumProvider: commonEnumProviders.characters('all'),
+                forceEnum: true,
             }),
         ],
         helpString: 'Opens up a chat with the character or group by its name',

         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'name',
-                description: 'character name',
+                description: 'Character name - or unique character identifier (avatar key)',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 enumProvider: commonEnumProviders.characters('character'),

         namedArgumentList: [],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'name',
+                description: 'Character name - or unique character identifier (avatar key)',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 enumProvider: commonEnumProviders.characters('character'),

         aliases: ['addmember', 'memberadd'],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'character name',
+                description: 'Character name - or unique character identifier (avatar key)',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 enumProvider: () => selected_group ? commonEnumProviders.characters('character')() : [],

             ),
             SlashCommandNamedArgument.fromProps({
                 name: 'name',
-                description: 'in-prompt name for instruct mode',
+                description: 'in-prompt character name for instruct mode (or unique character identifier (avatar key), which will be used as name)',
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: 'System',
                 enumProvider: () => [...commonEnumProviders.characters('character')(), new SlashCommandEnumValue('System', null, enumTypes.enum, enumIcons.assistant)],

         setEphemeralStopStrings(resolveVariable(args?.stop));
         const name = args?.name;
-        const result = await generateQuietPrompt(value, quietToLoud, false, '', name, length);
+        const char = findChar({ name: name });
+        const result = await generateQuietPrompt(value, quietToLoud, false, '', char?.name ?? name, length);
         return result;
     } catch (err) {
         console.error('Error on /gen generation', err);

         return '';
+    }
-    let name = '';
+    if (!args.name) {
+        toastr.warning('You must specify a name of the character to ask.');
-    if (args?.name) {
+        return '';
-        name = args.name.trim();
-        if (!name) {
-            toastr.warning('You must specify a name of the character to ask.');
-            return '';
-        }
+    }
     const prevChId = this_chid;
     // Find the character
-    const chId = characters.findIndex((e) => e.name === name || e.avatar === name);
+    const character = findChar({ name: args?.name });
-    if (!characters[chId] || chId === -1) {
+    if (!character) {
         toastr.error('Character not found.');
         return '';
+    }
+    const chId = getCharIndex(character);
     if (text) {
         const mesText = getRegexedString(text.trim(), regex_placement.SLASH_COMMAND);
         // Sending a message implicitly saves the chat, so this needs to be done before changing the character

     // Override character and send a user message
     setCharacterId(String(chId));
-    const character = characters[chId];
+    const { name, force_avatar, original_avatar } = getNameAndAvatarForMessage(character, args?.name);
-    let force_avatar, original_avatar;
-    if (character && character.avatar !== 'none') {
+    setCharacterName(name);
-        force_avatar = getThumbnailUrl('avatar', character.avatar);
-        original_avatar = character.avatar;
-    }
-    else {
-        force_avatar = default_avatar;
-        original_avatar = default_avatar;
-    }
-    setCharacterName(character.name);
     const restoreCharacter = () => {
         if (String(this_chid) !== String(chId)) {
             return;
+        }
-        setCharacterId(prevChId);
+        if (prevChId !== undefined) {
-        setCharacterName(characters[prevChId].name);
+            setCharacterId(prevChId);
+            setCharacterName(characters[prevChId].name);
+        } else {
+            setCharacterId(undefined);
+            setCharacterName(neutralCharacterName);
+        }
         // Only force the new avatar if the character name is the same
         // This skips if an error was fired
         const lastMessage = chat[chat.length - 1];
-        if (lastMessage && lastMessage?.name === character.name) {
+        if (lastMessage && lastMessage?.name === name) {
             lastMessage.force_avatar = force_avatar;
             lastMessage.original_avatar = original_avatar;
+        }

     // Run generate and restore previous character
     try {
         eventSource.once(event_types.MESSAGE_RECEIVED, restoreCharacter);
-        toastr.info(`Asking ${character.name} something...`);
+        toastr.info(`Asking ${name} something...`);
         askResult = await Generate('ask_command');
     } catch (error) {
         restoreCharacter();

     return '';
+}
-async function addGroupMemberCallback(_, arg) {
+async function addGroupMemberCallback(_, name) {
     if (!selected_group) {
         toastr.warning('Cannot run /memberadd command outside of a group chat.');
         return '';
+    }
-    if (!arg) {
+    if (!name) {
         console.warn('WARN: No argument provided for /memberadd command');
         return '';
+    }
-    arg = arg.trim();
+    const character = findChar({ name: name, preferCurrentChar: false });
-    const chid = findCharacterIndex(arg);
+    if (!character) {
+        console.warn(`WARN: No character found for argument ${name}`);
-    if (chid === -1) {
-        console.warn(`WARN: No character found for argument ${arg}`);
         return '';
+    }
-    const character = characters[chid];
     const group = groups.find(x => x.id === selected_group);
     if (!group || !Array.isArray(group.members)) {

@@ -2829,7 +2899,7 @@ function findPersonaByName(name) {
2829	}	2899	}
2830		2900
2831	for (const persona of Object.entries(power_user.personas)) {	2901	for (const persona of Object.entries(power_user.personas)) {
2832	if (persona[1].toLowerCase() === name.toLowerCase()) {	2902	if (equalsIgnoreCaseAndAccents(persona[1], name)) {
2833	return persona[0];	2903	return persona[0];
2834	}	2904	}
2835	}	2905	}

         return;
+    }
-    name = name.trim();
+    // Search for a matching character to get the real name, or take the name provided
+    const character = findChar({ name: name });
+    name = character?.name || name;
     const messagesToDelete = [];
     chat.forEach((value) => {

     return '';
+}
-function findCharacterIndex(name) {
-    const matchTypes = [
-        (a, b) => a === b,
-        (a, b) => a.startsWith(b),
-        (a, b) => a.includes(b),
-    ];
-    const exactAvatarMatch = characters.findIndex(x => x.avatar === name);
-    if (exactAvatarMatch !== -1) {
-        return exactAvatarMatch;
-    }
-    for (const matchType of matchTypes) {
-        const index = characters.findIndex(x => matchType(x.name.toLowerCase(), name.toLowerCase()));
-        if (index !== -1) {
-            return index;
-        }
-    }
-    return -1;
-}
 async function goToCharacterCallback(_, name) {
     if (!name) {
         console.warn('WARN: No character name provided for /go command');
         return;
+    }
-    name = name.trim();
+    const character = findChar({ name: name });
-    const characterIndex = findCharacterIndex(name);
+    if (character) {
+        const chid = getCharIndex(character);
-    if (characterIndex !== -1) {
+        await openChat(new String(chid));
-        await openChat(new String(characterIndex));
+        setActiveCharacter(character.avatar);
-        setActiveCharacter(characters[characterIndex]?.avatar);
         setActiveGroup(null);
-        return characters[characterIndex]?.name;
+        return character.name;
-    } else {
-        const group = groups.find(it => it.name.toLowerCase() == name.toLowerCase());
-        if (group) {
-            await openGroupById(group.id);
-            setActiveCharacter(null);
-            setActiveGroup(group.id);
-            return group.name;
-        } else {
-            console.warn(`No matches found for name "${name}"`);
-            return '';
-        }
+    }
+    const group = groups.find(it => equalsIgnoreCaseAndAccents(it.name, name));
+    if (group) {
+        await openGroupById(group.id);
+        setActiveCharacter(null);
+        setActiveGroup(group.id);
+        return group.name;
+    }
+    console.warn(`No matches found for name "${name}"`);
+    return '';
+}
-async function openChat(id) {
+async function openChat(chid) {
     resetSelectedGroup();
-    setCharacterId(id);
+    setCharacterId(chid);
     await delay(1);
     await reloadCurrentChat();
+}

     return '';
+}
+/**
+ * Checks if an argument is a string array (or undefined), and if not, throws an error
+ * @param {string|SlashCommandClosure|(string|SlashCommandClosure)[]|undefined} arg The named argument to check
+ * @param {string} name The name of the argument for the error message
+ * @param {object} [options={}] - The optional arguments
+ * @param {boolean} [options.allowUndefined=false] - Whether the argument can be undefined
+ * @throws {Error} If the argument is not an array
+ * @returns {string[]}
+ */
+export function validateArrayArgString(arg, name, { allowUndefined = true } = {}) {
+    if (arg === undefined) {
+        if (allowUndefined) return undefined;
+        throw new Error(`Argument "${name}" is undefined, but must be a string array`);
+    }
+    if (!Array.isArray(arg)) throw new Error(`Argument "${name}" must be an array`);
+    if (!arg.every(x => typeof x === 'string')) throw new Error(`Argument "${name}" must be an array of strings`);
+    return arg;
+}
+/**
+ * Checks if an argument is a string or closure array (or undefined), and if not, throws an error
+ * @param {string|SlashCommandClosure|(string|SlashCommandClosure)[]|undefined} arg The named argument to check
+ * @param {string} name The name of the argument for the error message
+ * @param {object} [options={}] - The optional arguments
+ * @param {boolean} [options.allowUndefined=false] - Whether the argument can be undefined
+ * @throws {Error} If the argument is not an array of strings or closures
+ * @returns {(string|SlashCommandClosure)[]}
+ */
+export function validateArrayArg(arg, name, { allowUndefined = true } = {}) {
+    if (arg === undefined) {
+        if (allowUndefined) return [];
+        throw new Error(`Argument "${name}" is undefined, but must be an array of strings or closures`);
+    }
+    if (!Array.isArray(arg)) throw new Error(`Argument "${name}" must be an array`);
+    if (!arg.every(x => typeof x === 'string' || x instanceof SlashCommandClosure)) throw new Error(`Argument "${name}" must be an array of strings or closures`);
+    return arg;
+}
+/**
+ * Retrieves the name and avatar information for a message
+ *
+ * The name of the character will always have precendence over the one given as argument. If you want to specify a different name for the message,
+ * explicitly implement this in the code using this.
+ *
+ * @param {object?} character - The character object to get the avatar data for
+ * @param {string?} name - The name to get the avatar data for
+ * @returns {{name: string, force_avatar: string, original_avatar: string}} An object containing the name for the message, forced avatar URL, and original avatar
+ */
+export function getNameAndAvatarForMessage(character, name = null) {
+    const isNeutralCharacter = !character && name2 === neutralCharacterName && name === neutralCharacterName;
+    const currentChar = characters[this_chid];
+    let force_avatar, original_avatar;
+    if (character?.avatar === currentChar?.avatar || isNeutralCharacter) {
+        // If the targeted character is the currently selected one in a solo chat, we don't need to force any avatars
+    }
+    else if (character && character.avatar !== 'none') {
+        force_avatar = getThumbnailUrl('avatar', character.avatar);
+        original_avatar = character.avatar;
+    }
+    else {
+        force_avatar = default_avatar;
+        original_avatar = default_avatar;
+    }
+    return {
+        name: character?.name || name,
+        force_avatar: force_avatar,
+        original_avatar: original_avatar,
+    };
+}
 export async function sendMessageAs(args, text) {
     if (!text) {
         return '';

     const isSystem = bias && !removeMacros(mesText).length;
     const compact = isTrueBoolean(args?.compact);
-    const character = characters.find(x => x.avatar === name) ?? characters.find(x => x.name === name);
+    const character = findChar({ name: name });
-    let force_avatar, original_avatar;
-    const chatCharacter = this_chid !== undefined ? characters[this_chid] : null;
-    const isNeutralCharacter = !chatCharacter && name2 === neutralCharacterName && name === neutralCharacterName;
-    if (chatCharacter === character || isNeutralCharacter) {
+    const avatarCharacter = args.avatar ? findChar({ name: args.avatar }) : character;
-        // If the targeted character is the currently selected one in a solo chat, we don't need to force any avatars
+    if (args.avatar && !avatarCharacter) {
-    }
+        toastr.warning(`Character for avatar ${args.avatar} not found`);
-    else if (character && character.avatar !== 'none') {
+        return '';
-        force_avatar = getThumbnailUrl('avatar', character.avatar);
-        original_avatar = character.avatar;
-    }
-    else {
-        force_avatar = default_avatar;
-        original_avatar = default_avatar;
+    }
+    const { name: avatarCharName, force_avatar, original_avatar } = getNameAndAvatarForMessage(avatarCharacter, name);
     const message = {
-        name: name,
+        name: character?.name || name || avatarCharName,
         is_user: false,
         is_system: isSystem,
         send_date: getMessageTimeStamp(),

     const prompts = promptManager.serviceSettings.prompts;
     function parseArgs(arg) {
+        // Arg is already an array
+        if (Array.isArray(arg)) {
+            return arg;
+        }
         const list = [];
         try {
+            // Arg is a JSON-stringified array
             const parsedArg = JSON.parse(arg);
             list.push(...Array.isArray(parsedArg) ? parsedArg : [arg]);
         } catch {
+            // Arg is a string
             list.push(arg);
+        }
         return list;

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

  * _abortController:SlashCommandAbortController,
  * _debugController:SlashCommandDebugController,
  * _hasUnnamedArgument:boolean,
- * [id:string]:string|SlashCommandClosure,
+ * [id:string]:string|SlashCommandClosure|(string|SlashCommandClosure)[]|undefined,
  * }} NamedArguments
  */
 /**
  * Alternative object for local JSDocs, where you don't need existing pipe, scope, etc. arguments
- * @typedef {{[id:string]:string|SlashCommandClosure}} NamedArgumentsCapture
+ * @typedef {{[id:string]:string|SlashCommandClosure|(string|SlashCommandClosure)[]|undefined}} NamedArgumentsCapture
  */
 /**

public/scripts/slash-commands/SlashCommandClosure.js+60 -11 Viewed

 import { delay, escapeRegex, uuidv4 } from '../utils.js';
 import { SlashCommand } from './SlashCommand.js';
 import { SlashCommandAbortController } from './SlashCommandAbortController.js';
+import { SlashCommandNamedArgument } from './SlashCommandArgument.js';
 import { SlashCommandBreak } from './SlashCommandBreak.js';
 import { SlashCommandBreakController } from './SlashCommandBreakController.js';
 import { SlashCommandBreakPoint } from './SlashCommandBreakPoint.js';

+     *
      * @param {string} text
      * @param {SlashCommandScope} scope
-     * @returns
+     * @returns {string|SlashCommandClosure|(string|SlashCommandClosure)[]}
      */
     substituteParams(text, scope = null) {
         let isList = false;

      * @param {import('./SlashCommand.js').NamedArguments} args
      */
     async substituteNamedArguments(executor, args) {
+        /**
+         * Handles the assignment of named arguments, considering if they accept multiple values
+         * @param {string} name The name of the argument, as defined for the command execution
+         * @param {string|SlashCommandClosure|(string|SlashCommandClosure)[]} value The value to be assigned
+         */
+        const assign = (name, value) => {
+            // If an array is supposed to be assigned, assign it one by one
+            if (Array.isArray(value)) {
+                for (const val of value) {
+                    assign(name, val);
+                }
+                return;
+            }
+            const definition = executor.command.namedArgumentList.find(x => x.name == name);
+            // Prefer definition name if a valid named args defintion is found
+            name = definition?.name ?? name;
+            // Unescape named argument
+            if (value && typeof value == 'string') {
+                value = value
+                    .replace(/\\\{/g, '{')
+                    .replace(/\\\}/g, '}');
+            }
+            // If the named argument accepts multiple values, we have to make sure to build an array correctly
+            if (definition?.acceptsMultiple) {
+                if (args[name] !== undefined) {
+                    // If there already is something for that named arg, make the value is an array and add to it
+                    let currentValue = args[name];
+                    if (!Array.isArray(currentValue)) {
+                        currentValue = [currentValue];
+                    }
+                    currentValue.push(value);
+                    args[name] = currentValue;
+                } else {
+                    // If there is nothing in there, we create an array with that singular value
+                    args[name] = [value];
+                }
+            } else {
+                args[name] !== undefined && console.debug(`Named argument assigned multiple times: ${name}`);
+                args[name] = value;
+            }
+        };
         // substitute named arguments
         for (const arg of executor.namedArgumentList) {
             if (arg.value instanceof SlashCommandClosure) {

@@ -390,19 +437,12 @@ export class SlashCommandClosure {
390	closure.debugController = this.debugController;	437	closure.debugController = this.debugController;
391	}	438	}
392	if (closure.executeNow) {	439	if (closure.executeNow) {
393	args[arg.name] = (await closure.execute())?.pipe;	440	assign(arg.name, (await closure.execute())?.pipe);
394	} else {	441	} else {
395	args[arg.name] = closure;	442	assign(arg.name, closure);
396	}	443	}
397	} else {	444	} else {
398	args[arg.name] = this.substituteParams(arg.value);	445	assign(arg.name, this.substituteParams(arg.value));
399	}
400	// unescape named argument
401	if (typeof args[arg.name] == 'string') {
402	args[arg.name] = args[arg.name]
403	?.replace(/\\\{/g, '{')
404	?.replace(/\\\}/g, '}')
405	;
406	}	446	}
407	}	447	}
408	}	448	}

         } else {
             value = [];
             for (let i = 0; i < executor.unnamedArgumentList.length; i++) {
+                /** @type {string|SlashCommandClosure|(string|SlashCommandClosure)[]} */
                 let v = executor.unnamedArgumentList[i].value;
                 if (v instanceof SlashCommandClosure) {
                     /**@type {SlashCommandClosure}*/

                 return v;
             });
+        }
+        value ??= '';
+        // Make sure that if unnamed args are split, it should always return an array
+        if (executor.command.splitUnnamedArgument && !Array.isArray(value)) {
+            value = [value];
+        }
         return value;
+    }

public/scripts/slash-commands/SlashCommandCommonEnumsProvider.js+43 -2 Viewed

 import { extension_settings } from '../extensions.js';
 import { getGroupMembers, groups } from '../group-chats.js';
 import { power_user } from '../power-user.js';
-import { searchCharByName, getTagsList, tags } from '../tags.js';
+import { searchCharByName, getTagsList, tags, tag_map } from '../tags.js';
 import { world_names } from '../world-info.js';
 import { SlashCommandClosure } from './SlashCommandClosure.js';
 import { SlashCommandEnumValue, enumTypes } from './SlashCommandEnumValue.js';

     },
     /**
+     * Enum values for numbers and variable names
+     *
+     * Includes all variable names and the ability to specify any number
+     *
+     * @param {SlashCommandExecutor} executor - The executor of the slash command
+     * @param {SlashCommandScope} scope - The scope of the slash command
+     * @returns {SlashCommandEnumValue[]} The enum values
+     */
+    numbersAndVariables: (executor, scope) => [
+        ...commonEnumProviders.variables('all')(executor, scope),
+        new SlashCommandEnumValue(
+            'any variable name',
+            null,
+            enumTypes.variable,
+            enumIcons.variable,
+            (input) => /^\w*$/.test(input),
+            (input) => input,
+        ),
+        new SlashCommandEnumValue(
+            'any number',
+            null,
+            enumTypes.number,
+            enumIcons.number,
+            (input) => input == '' || !Number.isNaN(Number(input)),
+            (input) => input,
+        ),
+    ],
+    /**
      * All possible char entities, like characters and groups. Can be filtered down to just one type.
+     *
      * @param {('all' | 'character' | 'group')?} [mode='all'] - Which type to return

     personas: () => Object.values(power_user.personas).map(persona => new SlashCommandEnumValue(persona, null, enumTypes.name, enumIcons.persona)),
     /**
+     * All possible tags, or only those that have been assigned
+     *
+     * @param {('all' | 'assigned')} [mode='all'] - Which types of tags to show
+     * @returns {() => SlashCommandEnumValue[]}
+     */
+    tags: (mode = 'all') => () => {
+        let assignedTags = mode === 'assigned' ? new Set(Object.values(tag_map).flat()) : new Set();
+        return tags.filter(tag => mode === 'all' || (mode === 'assigned' && assignedTags.has(tag.id)))
+            .map(tag => new SlashCommandEnumValue(tag.name, null, enumTypes.command, enumIcons.tag));
+    },
+    /**
      * All possible tags for a given char/group entity
+     *
      * @param {('all' | 'existing' | 'not-existing')?} [mode='all'] - Which types of tags to show

         if (charName instanceof SlashCommandClosure) throw new Error('Argument \'name\' does not support closures');
         const key = searchCharByName(substituteParams(charName), { suppressLogging: true });
         const assigned = key ? getTagsList(key) : [];
-        return tags.filter(it => !key || mode === 'all' || mode === 'existing' && assigned.includes(it) || mode === 'not-existing' && !assigned.includes(it))
+        return tags.filter(it => mode === 'all' || mode === 'existing' && assigned.includes(it) || mode === 'not-existing' && !assigned.includes(it))
             .map(tag => new SlashCommandEnumValue(tag.name, null, enumTypes.command, enumIcons.tag));
     },

public/scripts/tags.js+8 -8 Viewed

 import { FILTER_TYPES, FILTER_STATES, DEFAULT_FILTER_STATE, isFilterState, FilterHelper } from './filters.js';
 import { groupCandidatesFilter, groups, selected_group } from './group-chats.js';
-import { download, onlyUnique, parseJsonFile, uuidv4, getSortableDelay, flashHighlight, equalsIgnoreCaseAndAccents, includesIgnoreCaseAndAccents, removeFromArray, getFreeName, debounce } from './utils.js';
+import { download, onlyUnique, parseJsonFile, uuidv4, getSortableDelay, flashHighlight, equalsIgnoreCaseAndAccents, includesIgnoreCaseAndAccents, removeFromArray, getFreeName, debounce, findChar } from './utils.js';
 import { power_user } from './power-user.js';
 import { SlashCommandParser } from './slash-commands/SlashCommandParser.js';
 import { SlashCommand } from './slash-commands/SlashCommand.js';

     removeTagFromMap,
 };
-/** @typedef {import('../scripts/popup.js').Popup} Popup */
 /** @typedef {import('../script.js').Character} Character */
 const CHARACTER_FILTER_SELECTOR = '#rm_characters_block .rm_tag_filter';

  */
 export function searchCharByName(charName, { suppressLogging = false } = {}) {
     const entity = charName
-        ? (characters.find(x => x.name === charName) || groups.find(x => x.name == charName))
+        ? (findChar({ name: charName }) || groups.find(x => equalsIgnoreCaseAndAccents(x.name, charName)))
         : (selected_group ? groups.find(x => x.id == selected_group) : characters[this_chid]);
     const key = getTagKeyForEntity(entity);
     if (!key) {

             return String(result);
         },
         namedArgumentList: [
-            SlashCommandNamedArgument.fromProps({ name: 'name',
+            SlashCommandNamedArgument.fromProps({
-                description: 'Character name',
+                name: 'name',
+                description: 'Character name - or unique character identifier (avatar key)',
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: '{{char}}',
                 enumProvider: commonEnumProviders.characters(),

         },
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({ name: 'name',
-                description: 'Character name',
+                description: 'Character name - or unique character identifier (avatar key)',
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: '{{char}}',
                 enumProvider: commonEnumProviders.characters(),

         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'name',
-                description: 'Character name',
+                description: 'Character name - or unique character identifier (avatar key)',
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: '{{char}}',
                 enumProvider: commonEnumProviders.characters(),

         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'name',
-                description: 'Character name',
+                description: 'Character name - or unique character identifier (avatar key)',
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: '{{char}}',
                 enumProvider: commonEnumProviders.characters(),

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

 import { getContext } from './extensions.js';
-import { getRequestHeaders } from '../script.js';
+import { characters, getRequestHeaders, this_chid } from '../script.js';
 import { isMobile } from './RossAscends-mods.js';
 import { collapseNewlines } from './power-user.js';
 import { debounce_timeout } from './constants.js';
 import { Popup, POPUP_RESULT, POPUP_TYPE } from './popup.js';
 import { SlashCommandClosure } from './slash-commands/SlashCommandClosure.js';
+import { getTagsList } from './tags.js';
+import { groups, selected_group } from './group-chats.js';
 /**
  * Pagination status string template.

+    }
     return null;
+}
+/**
+ * Finds a character by name, with optional filtering and precedence for avatars
+ * @param {object} [options={}] - The options for the search
+ * @param {string?} [options.name=null] - The name to search for
+ * @param {boolean} [options.allowAvatar=true] - Whether to allow searching by avatar
+ * @param {boolean} [options.insensitive=true] - Whether the search should be case insensitive
+ * @param {string[]?} [options.filteredByTags=null] - Tags to filter characters by
+ * @param {boolean} [options.preferCurrentChar=true] - Whether to prefer the current character(s)
+ * @param {boolean} [options.quiet=false] - Whether to suppress warnings
+ * @returns {any?} - The found character or null if not found
+ */
+export function findChar({ name = null, allowAvatar = true, insensitive = true, filteredByTags = null, preferCurrentChar = true, quiet = false } = {}) {
+    const matches = (char) => !name || (allowAvatar && char.avatar === name) || (insensitive ? equalsIgnoreCaseAndAccents(char.name, name) : char.name === name);
+    // Filter characters by tags if provided
+    let filteredCharacters = characters;
+    if (filteredByTags) {
+        filteredCharacters = characters.filter(char => {
+            const charTags = getTagsList(char.avatar, false);
+            return filteredByTags.every(tagName => charTags.some(x => x.name == tagName));
+        });
+    }
+    // Get the current character(s)
+    /** @type {any[]} */
+    const currentChars = selected_group ? groups.find(group => group.id === selected_group)?.members.map(member => filteredCharacters.find(char => char.avatar === member))
+        : filteredCharacters.filter(char => characters[this_chid]?.avatar === char.avatar);
+    // If we have a current char and prefer it, return that if it matches
+    if (preferCurrentChar) {
+        const preferredCharSearch = currentChars.filter(matches);
+        if (preferredCharSearch.length > 1) {
+            if (!quiet) toastr.warning('Multiple characters found for given conditions.');
+            else console.warn('Multiple characters found for given conditions. Returning the first match.');
+        }
+        if (preferredCharSearch.length) {
+            return preferredCharSearch[0];
+        }
+    }
+    // If allowAvatar is true, search by avatar first
+    if (allowAvatar && name) {
+        const characterByAvatar = filteredCharacters.find(char => char.avatar === name);
+        if (characterByAvatar) {
+            return characterByAvatar;
+        }
+    }
+    // Search for matching characters by name
+    const matchingCharacters = name ? filteredCharacters.filter(matches) : filteredCharacters;
+    if (matchingCharacters.length > 1) {
+        if (!quiet) toastr.warning('Multiple characters found for given conditions.');
+        else console.warn('Multiple characters found for given conditions. Returning the first match.');
+    }
+    return matchingCharacters[0] || null;
+}
+/**
+ * Gets the index of a character based on the character object
+ * @param {object} char - The character object to find the index for
+ * @throws {Error} If the character is not found
+ * @returns {number} The index of the character in the characters array
+ */
+export function getCharIndex(char) {
+    if (!char) throw new Error('Character is undefined');
+    const index = characters.findIndex(c => c.avatar === char.avatar);
+    if (index === -1) throw new Error(`Character not found: ${char.avatar}`);
+    return index;
+}

public/scripts/variables.js+77 -58 Viewed

+}
 /**
- * Parses a series of numeric values from a string.
+ * Parses a series of numeric values from a string or a string array.
- * @param {string} value A space-separated list of numeric values or variable names
+ * @param {string|string[]} value A space-separated list of numeric values or variable names
  * @param {SlashCommandScope} scope Scope
  * @returns {number[]} An array of numeric values
  */

         return [value];
+    }
-    const array = value
+    /** @type {(string|number)[]} */
-        .split(' ')
+    let values = Array.isArray(value) ? value : value.split(' ');
-        .map(i => i.trim())
+    // If a JSON array was provided as the only value, convert it to an array
+    if (values.length === 1 && typeof values[0] === 'string' && values[0].startsWith('[')) {
+        values = convertValueType(values[0], 'array');
+    }
+    const array = values.map(i => typeof i === 'string' ? i.trim() : i)
         .filter(i => i !== '')
-        .map(i => isNaN(Number(i)) ? Number(resolveVariable(i, scope)) : Number(i))
+        .map(i => isNaN(Number(i)) ? Number(resolveVariable(String(i), scope)) : Number(i))
         .filter(i => !isNaN(i));
     return array;

@@ -703,7 +709,7 @@ function performOperation(value, operation, singleOperand = false, scope = null)
703		709
704	const result = singleOperand ? operation(array[0]) : operation(array);	710	const result = singleOperand ? operation(array[0]) : operation(array);
705		711
706	if (isNaN(result) \|\| !isFinite(result)) {	712	if (isNaN(result)) {
707	return 0;	713	return 0;
708	}	714	}
709		715

@@ -731,7 +737,7 @@ function maxValuesCallback(args, value) {
731	}	737	}
732		738
733	function subValuesCallback(args, value) {	739	function subValuesCallback(args, value) {
734	return performOperation(value, (array) => array[0] - array[1], false, args._scope);	740	return performOperation(value, (array) => array.reduce((a, b) => a - b, array.shift() ?? 0), false, args._scope);
735	}	741	}
736		742
737	function divValuesCallback(args, value) {	743	function divValuesCallback(args, value) {

     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'add',
-        callback: (args, /**@type {string[]}*/value) => addValuesCallback(args, value.join(' ')),
+        callback: (args, value) => addValuesCallback(args, value),
         returns: 'sum of the provided values',
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
                 description: 'values to sum',
-                typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
+                typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME, ARGUMENT_TYPE.LIST],
                 isRequired: true,
                 acceptsMultiple: true,
-                enumProvider: (executor, scope) => {
+                enumProvider: commonEnumProviders.numbersAndVariables,
-                    const vars = commonEnumProviders.variables('all')(executor, scope);
-                    vars.push(
-                        new SlashCommandEnumValue(
-                            'any variable name',
-                            null,
-                            enumTypes.variable,
-                            enumIcons.variable,
-                            (input) => /^\w*$/.test(input),
-                            (input) => input,
-                        ),
-                        new SlashCommandEnumValue(
-                            'any number',
-                            null,
-                            enumTypes.number,
-                            enumIcons.number,
-                            (input) => input == '' || !Number.isNaN(Number(input)),
-                            (input) => input,
-                        ),
-                    );
-                    return vars;
-                },
                 forceEnum: false,
             }),
         ],

         helpString: `
             <div>
                 Performs an addition of the set of values and passes the result down the pipe.
-                Can use variable names.
+            </div>
+            <div>
+                Can use variable names, or a JSON array consisting of numbers and variables (with quotes).
             </div>
             <div>
                 <strong>Example:</strong>

                     <li>
                         <pre><code class="language-stscript">/add 10 i 30 j</code></pre>
                     </li>
+                    <li>
+                        <pre><code class="language-stscript">/add ["count", 15, 2, "i"]</code></pre>
+                    </li>
                 </ul>
             </div>
         `,

         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
                 description: 'values to multiply',
-                typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
+                typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME, ARGUMENT_TYPE.LIST],
                 isRequired: true,
                 acceptsMultiple: true,
-                enumProvider: commonEnumProviders.variables('all'),
+                enumProvider: commonEnumProviders.numbersAndVariables,
                 forceEnum: false,
             }),
         ],
+        splitUnnamedArgument: true,
         helpString: `
             <div>
-                Performs a multiplication of the set of values and passes the result down the pipe. Can use variable names.
+                Performs a multiplication of the set of values and passes the result down the pipe.
+            </div>
+            <div>
+                Can use variable names, or a JSON array consisting of numbers and variables (with quotes).
             </div>
             <div>
                 <strong>Examples:</strong>

                     <li>
                         <pre><code class="language-stscript">/mul 10 i 30 j</code></pre>
                     </li>
+                    <li>
+                        <pre><code class="language-stscript">/mul ["count", 15, 2, "i"]</code></pre>
+                    </li>
                 </ul>
             </div>
         `,

         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
                 description: 'values to find the max',
-                typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
+                typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME, ARGUMENT_TYPE.LIST],
                 isRequired: true,
                 acceptsMultiple: true,
-                enumProvider: commonEnumProviders.variables('all'),
+                enumProvider: commonEnumProviders.numbersAndVariables,
                 forceEnum: false,
             }),
         ],
+        splitUnnamedArgument: true,
         helpString: `
             <div>
-                Returns the maximum value of the set of values and passes the result down the pipe. Can use variable names.
+                Returns the maximum value of the set of values and passes the result down the pipe.
+            </div>
+            <div>
+                Can use variable names, or a JSON array consisting of numbers and variables (with quotes).
             </div>
             <div>
                 <strong>Examples:</strong>

                     <li>
                         <pre><code class="language-stscript">/max 10 i 30 j</code></pre>
                     </li>
+                    <li>
+                        <pre><code class="language-stscript">/max ["count", 15, 2, "i"]</code></pre>
+                    </li>
                 </ul>
             </div>
         `,

         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
                 description: 'values to find the min',
-                typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
+                typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME, ARGUMENT_TYPE.LIST],
                 isRequired: true,
                 acceptsMultiple: true,
-                enumProvider: commonEnumProviders.variables('all'),
+                enumProvider: commonEnumProviders.numbersAndVariables,
                 forceEnum: false,
             }),
         ],
+        splitUnnamedArgument: true,
         helpString: `
             <div>
                 Returns the minimum value of the set of values and passes the result down the pipe.
-                Can use variable names.
+            </div>
+            <div>
+                Can use variable names, or a JSON array consisting of numbers and variables (with quotes).
             </div>
             <div>
                 <strong>Example:</strong>

                     <li>
                         <pre><code class="language-stscript">/min 10 i 30 j</code></pre>
                     </li>
+                    <li>
+                        <pre><code class="language-stscript">/min ["count", 15, 2, "i"]</code></pre>
+                    </li>
                 </ul>
             </div>
         `,

         returns: 'difference of the provided values',
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'values to find the difference',
+                description: 'values to subtract, starting form the first provided value',
-                typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
+                typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME, ARGUMENT_TYPE.LIST],
                 isRequired: true,
                 acceptsMultiple: true,
-                enumProvider: commonEnumProviders.variables('all'),
+                enumProvider: commonEnumProviders.numbersAndVariables,
                 forceEnum: false,
             }),
         ],
+        splitUnnamedArgument: true,
         helpString: `
             <div>
                 Performs a subtraction of the set of values and passes the result down the pipe.
-                Can use variable names.
+            </div>
+            <div>
+                Can use variable names, or a JSON array consisting of numbers and variables (with quotes).
             </div>
             <div>
                 <strong>Example:</strong>

                     <li>
                         <pre><code class="language-stscript">/sub i 5</code></pre>
                     </li>
+                    <li>
+                        <pre><code class="language-stscript">/sub ["count", 4, "i"]</code></pre>
+                    </li>
                 </ul>
             </div>
         `,

                 description: 'dividend',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
-                enumProvider: commonEnumProviders.variables('all'),
+                enumProvider: commonEnumProviders.numbersAndVariables,
                 forceEnum: false,
             }),
             SlashCommandArgument.fromProps({
                 description: 'divisor',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
-                enumProvider: commonEnumProviders.variables('all'),
+                enumProvider: commonEnumProviders.numbersAndVariables,
                 forceEnum: false,
             }),
         ],
+        splitUnnamedArgument: true,
         helpString: `
             <div>
                 Performs a division of two values and passes the result down the pipe.

                 description: 'dividend',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
-                enumProvider: commonEnumProviders.variables('all'),
+                enumProvider: commonEnumProviders.numbersAndVariables,
                 forceEnum: false,
             }),
             SlashCommandArgument.fromProps({
                 description: 'divisor',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
-                enumProvider: commonEnumProviders.variables('all'),
+                enumProvider: commonEnumProviders.numbersAndVariables,
                 forceEnum: false,
             }),
         ],
+        splitUnnamedArgument: true,
         helpString: `
             <div>
                 Performs a modulo operation of two values and passes the result down the pipe.

                 description: 'base',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
-                enumProvider: commonEnumProviders.variables('all'),
+                enumProvider: commonEnumProviders.numbersAndVariables,
                 forceEnum: false,
             }),
             SlashCommandArgument.fromProps({
                 description: 'exponent',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
-                enumProvider: commonEnumProviders.variables('all'),
+                enumProvider: commonEnumProviders.numbersAndVariables,
                 forceEnum: false,
             }),
         ],
+        splitUnnamedArgument: true,
         helpString: `
             <div>
                 Performs a power operation of two values and passes the result down the pipe.

                 description: 'value',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
-                enumProvider: commonEnumProviders.variables('all'),
+                enumProvider: commonEnumProviders.numbersAndVariables,
                 forceEnum: false,
             }),
         ],

                 description: 'value',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
-                enumProvider: commonEnumProviders.variables('all'),
+                enumProvider: commonEnumProviders.numbersAndVariables,
                 forceEnum: false,
             }),
         ],

                 description: 'value',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
-                enumProvider: commonEnumProviders.variables('all'),
+                enumProvider: commonEnumProviders.numbersAndVariables,
                 forceEnum: false,
             }),
         ],

                 description: 'value',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
-                enumProvider: commonEnumProviders.variables('all'),
+                enumProvider: commonEnumProviders.numbersAndVariables,
                 forceEnum: false,
             }),
         ],

                 description: 'value',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
-                enumProvider: commonEnumProviders.variables('all'),
+                enumProvider: commonEnumProviders.numbersAndVariables,
                 forceEnum: false,
             }),
         ],

                 description: 'value',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
-                enumProvider: commonEnumProviders.variables('all'),
+                enumProvider: commonEnumProviders.numbersAndVariables,
                 forceEnum: false,
             }),
         ],

public/style.css+12 -3 Viewed

     justify-content: center;
     z-index: 9999;
     grid-row-start: 2;
-    grid-column-start: 4;
-    flex-flow: column;
     font-size: 30px;
     cursor: pointer;
     align-self: center;
     position: absolute;
-    bottom: 15px;
+bottom: 15px;
+flex-flow: column;
+}
 .swipes-counter {
     color: var(--SmartThemeBodyColor);
     font-size: 12px;

     font-family: var(--mainFontFamily);
     font-weight: 400;
     align-self: center;
+    min-width: 40px;
+    display: flex;
+    justify-content: center;
+}
 .swipe_left {

 .swipe_right {
     right: 5px;
+    align-self:end;
+}
 .ui-settings {

@@ -2634,6 +2638,11 @@ select option:not(:checked) {
2634	color: var(--active) !important;	2638	color: var(--active) !important;
2635	}	2639	}
2636		2640
		2641	#instruct_enabled_label .menu_button:not(.toggleEnabled),
		2642	#sysprompt_enabled_label .menu_button:not(.toggleEnabled) {
		2643	color: Red;
		2644	}
		2645
2637	.displayBlock {	2646	.displayBlock {
2638	display: block !important;	2647	display: block !important;
2639	}	2648	}