fix: Slash command descriptions and argument help text are not translated (#4434) * fix: Slash command descriptions and argument help text are not translated #4428 * fix * fix: Refine slash command translation scope per review * fix * Join split multiline strings * Revert error name --------- Co-authored-by: Cohee <18619528+Cohee1207@users.noreply.github.com>

f9d1279a69270109ebf0aa80ca84220a9688c34d

MAX-TAB <60381043+MAX-TAB@users.noreply.github.com>

Signed

Parents: f81088f2e05da0f923203b84e110db2df8f3d5b0

public/scripts/slash-commands.js+503 -512 Viewed

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'dupe',
         callback: duplicateCharacter,
-        helpString: 'Duplicates the currently selected character.',
+        helpString: t`Duplicates the currently selected character.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'api',

             toastr.clear(toast);
             return text?.toString()?.trim() ?? '';
         },
-        returns: 'the current API',
+        returns: t`the current API`,
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'quiet',
-                description: 'Suppress the toast message on connection',
+                description: t`Suppress the toast message on connection`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'false',
                 enumList: commonEnumProviders.boolean('trueFalse')(),

         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'API to connect to',
+                description: t`API to connect to`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 enumList: Object.entries(CONNECT_API_MAP).sort(([a], [b]) => a.localeCompare(b)).map(([api, { selected }]) =>
                     new SlashCommandEnumValue(api, selected, enumTypes.getBasedOnIndex(UNIQUE_APIS.findIndex(x => x === selected)),

         ],
         helpString: `
             <div>
-                Connect to an API. If no argument is provided, it will return the currently connected API.
+                ${t`Connect to an API. If no argument is provided, it will return the currently connected API.`}
             </div>
             <div>
-                <strong>Available APIs:</strong>
+                <strong>${t`Available APIs:`}</strong>
                 <pre><code>${Object.keys(CONNECT_API_MAP).sort((a, b) => a.localeCompare(b)).join(', ')}</code></pre>
             </div>
         `,

         namedArgumentList: [
             new SlashCommandNamedArgument(
                 'await',
-                'Whether to await for the triggered generation before continuing',
+                t`Whether to await for the triggered generation before continuing`,
                 [ARGUMENT_TYPE.BOOLEAN],
                 false,
                 false,

         ],
         helpString: `
             <div>
-                Calls an impersonation response, with an optional additional prompt.
+                ${t`Calls an impersonation response, with an optional additional prompt.`}
             </div>
             <div>
-                If <code>await=true</code> named argument is passed, the command will wait for the impersonation to end before continuing.
+                ${t`If <code>await=true</code> named argument is passed, the command will wait for the impersonation to end before continuing.`}
             </div>
             <div>
-                <strong>Example:</strong>
+                <strong>${t`Example:`}</strong>
                 <ul>
                     <li>
                         <pre><code class="language-stscript">/impersonate What is the meaning of life?</code></pre>

                 $(currentChatDeleteButton).trigger('click', { fromSlashCommand: true });
             }));
         },
-        helpString: 'Deletes the current chat.',
+        helpString: t`Deletes the current chat.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'renamechat',

         },
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'new chat name', [ARGUMENT_TYPE.STRING], true,
+                t`new chat name`, [ARGUMENT_TYPE.STRING], true,
             ),
         ],
-        helpString: 'Renames the current chat.',
+        helpString: t`Renames the current chat.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'getchatname',
         callback: async function doGetChatName() {
             return getCurrentChatDetails().sessionName;
         },
-        returns: 'chat file name',
+        returns: t`chat file name`,
-        helpString: 'Returns the name of the current chat file into the pipe.',
+        helpString: t`Returns the name of the current chat file into the pipe.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'closechat',

             $('#option_close_chat').trigger('click');
             return '';
         },
-        helpString: 'Closes the current chat.',
+        helpString: t`Closes the current chat.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'tempchat',

             return new Promise((resolve, reject) => {
                 const eventCallback = async (chatId) => {
                     if (chatId) {
-                        return reject('Not in a temporary chat');
+                        return reject(t`Not in a temporary chat`);
+                    }
                     await newAssistantChat({ temporary: true });
                     return resolve('');

                 eventSource.once(event_types.CHAT_CHANGED, eventCallback);
                 $('#option_close_chat').trigger('click');
                 setTimeout(() => {
-                    reject('Failed to open temporary chat');
+                    reject(t`Failed to open temporary chat`);
                     eventSource.removeListener(event_types.CHAT_CHANGED, eventCallback);
                 }, debounce_timeout.relaxed);
             });
         },
-        helpString: 'Opens a temporary chat with Assistant.',
+        helpString: t`Opens a temporary chat with Assistant.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'panels',

             return '';
         },
         aliases: ['togglepanels'],
-        helpString: 'Toggle UI panels on/off',
+        helpString: t`Toggle UI panels on/off`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'forcesave',
         callback: async function () {
             await saveSettings();
             await saveChatConditional();
-            toastr.success('Chat and settings saved.');
+            toastr.success(t`Chat and settings saved.`);
             return '';
         },
-        helpString: 'Forces a save of the current chat and settings',
+        helpString: t`Forces a save of the current chat and settings`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'instruct',

             selectInstructPreset(foundName, { quiet: quiet });
             return foundName;
         },
-        returns: 'current template',
+        returns: t`current template`,
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'quiet',
-                description: 'Suppress the toast message on template change',
+                description: t`Suppress the toast message on template change`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'false',
                 enumList: commonEnumProviders.boolean('trueFalse')(),
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'forceGet',
-                description: 'Force getting a name even if instruct mode is disabled',
+                description: t`Force getting a name even if instruct mode is disabled`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'false',
                 enumList: commonEnumProviders.boolean('trueFalse')(),

         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'instruct template name',
+                description: t`instruct template name`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 enumProvider: () => instruct_presets.map(preset => new SlashCommandEnumValue(preset.name, null, enumTypes.enum, enumIcons.preset)),
             }),
         ],
         helpString: `
             <div>
-                Selects instruct mode template by name. Enables instruct mode if not already enabled.
+                ${t`Selects instruct mode template by name. Enables instruct mode if not already enabled.`}
-                Gets the current instruct template if no name is provided and instruct mode is enabled or <code>forceGet=true</code> is passed.
+                ${t`Gets the current instruct template if no name is provided and instruct mode is enabled or <code>forceGet=true</code> is passed.`}
             </div>
             <div>
-                <strong>Example:</strong>
+                <strong>${t`Example:`}</strong>
                 <ul>
                     <li>
                         <pre><code class="language-stscript">/instruct creative</code></pre>

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'instruct-on',
         callback: enableInstructCallback,
-        helpString: 'Enables instruct mode.',
+        helpString: t`Enables instruct mode.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'instruct-off',
         callback: disableInstructCallback,
-        helpString: 'Disables instruct mode',
+        helpString: t`Disables instruct mode`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'instruct-state',
         aliases: ['instruct-toggle'],
-        helpString: 'Gets the current instruct mode state. If an argument is provided, it will set the instruct mode state.',
+        helpString: t`Gets the current instruct mode state. If an argument is provided, it will set the instruct mode state.`,
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'instruct mode state',
+                description: t`instruct mode state`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 enumList: commonEnumProviders.boolean('trueFalse')(),
             }),

             selectContextPreset(foundName, { quiet: quiet });
             return foundName;
         },
-        returns: 'template name',
+        returns: t`template name`,
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'quiet',
-                description: 'Suppress the toast message on template change',
+                description: t`Suppress the toast message on template change`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'false',
                 enumList: commonEnumProviders.boolean('trueFalse')(),

         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'context template name',
+                description: t`context template name`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 enumProvider: () => context_presets.map(preset => new SlashCommandEnumValue(preset.name, null, enumTypes.enum, enumIcons.preset)),
             }),
         ],
-        helpString: 'Selects context template by name. Gets the current template if no name is provided',
+        helpString: t`Selects context template by name. Gets the current template if no name is provided`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'chat-manager',

             return '';
         },
         aliases: ['chat-history', 'manage-chats'],
-        helpString: 'Opens the chat manager for the current character/group.',
+        helpString: t`Opens the chat manager for the current character/group.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: '?',
         callback: helpCommandCallback,
         aliases: ['help'],
         unnamedArgumentList: [SlashCommandArgument.fromProps({
-            description: 'help topic',
+            description: t`help topic`,
             typeList: [ARGUMENT_TYPE.STRING],
             enumList: [
-                new SlashCommandEnumValue('slash', 'slash commands (STscript)', enumTypes.command, '/'),
+                new SlashCommandEnumValue('slash', t`slash commands (STscript)`, enumTypes.command, '/'),
-                new SlashCommandEnumValue('macros', '{{macros}} (text replacement)', enumTypes.macro, enumIcons.macro),
+                new SlashCommandEnumValue('macros', t`{{macros}} (text replacement)`, enumTypes.macro, enumIcons.macro),
-                new SlashCommandEnumValue('format', 'chat/text formatting', enumTypes.name, '★'),
+                new SlashCommandEnumValue('format', t`chat/text formatting`, enumTypes.name, '★'),
-                new SlashCommandEnumValue('hotkeys', 'keyboard shortcuts', enumTypes.enum, '⏎'),
+                new SlashCommandEnumValue('hotkeys', t`keyboard shortcuts`, enumTypes.enum, '⏎'),
             ],
         })],
-        helpString: 'Get help on macros, chat formatting and commands.',
+        helpString: t`Get help on macros, chat formatting and commands.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'bg',
         callback: setBackgroundCallback,
         aliases: ['background'],
-        returns: 'the current background',
+        returns: t`the current background`,
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'background filename',
+                description: t`background filename`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 enumProvider: () => [...document.querySelectorAll('.bg_example')]
                     .map(it => new SlashCommandEnumValue(it.getAttribute('bgfile')))

         ],
         helpString: `
         <div>
-            Sets a background according to the provided filename. Partial names allowed.
+            ${t`Sets a background according to the provided filename. Partial names allowed.`}
         </div>
         <div>
-            If no background is provided, this will return the currently selected background.
+            ${t`If no background is provided, this will return the currently selected background.`}
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/bg beach.jpg</code></pre>

         name: 'char-find',
         aliases: ['findchar'],
         callback: (args, name) => {
-            if (typeof name !== 'string') throw new Error('name must be a string');
+            if (typeof name !== 'string') throw new Error(t`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.preferCurrent instanceof SlashCommandClosure || Array.isArray(args.preferCurrent)) throw new Error(t`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');
+            if (args.quiet instanceof SlashCommandClosure || Array.isArray(args.quiet)) throw new Error(t`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',
+        returns: t`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.',
+                description: t`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',
+                description: t`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',
+                description: t`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)',
+                description: t`Character name - or unique character identifier (avatar key)`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 enumProvider: commonEnumProviders.characters('character'),
             }),
         ],
         helpString: `
         <div>
-            Searches for a character and returns its avatar key.
+            ${t`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
+            ${t`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.`}
-            if you have multiple characters with the same name.
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/char-find name="Chloe"</code></pre>
-                    Returns the avatar key for "Chloe".
+                    ${t`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".
+                    ${t`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,
+                    ${t`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.`}
-                    so you can actually select the character you are looking for.
                 </li>
             </ul>
         </div>

         name: 'sendas',
         rawQuotes: true,
         callback: sendMessageAs,
-        returns: 'Optionally the text of the sent message, if specified in the "return" argument',
+        returns: t`Optionally the text of the sent message, if specified in the "return" argument`,
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'name',
-                description: 'Character name - or unique character identifier (avatar key)',
+                description: t`Character name - or unique character identifier (avatar key)`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 enumProvider: commonEnumProviders.characters('character'),
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'avatar',
-                description: 'Character avatar override (Can be either avatar key or just the character name to pull the avatar from)',
+                description: t`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',
+                description: t`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 (including -0) 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.',
+                description: t`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 (including -0) 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.`,
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'return',
-                description: 'The way how you want the return value to be provided',
+                description: t`The way how you want the return value to be provided`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: 'none',
                 enumList: slashCommandReturnHelper.enumList({ allowObject: true }),

             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'raw',
-                description: 'If true, does not alter quoted literal unnamed arguments',
+                description: t`If true, does not alter quoted literal unnamed arguments`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'true',
                 enumProvider: commonEnumProviders.boolean('trueFalse'),

         ],
         helpString: `
         <div>
-            Sends a message as a specific character. Uses the character avatar if it exists in the characters list.
+            ${t`Sends a message as a specific character. Uses the character avatar if it exists in the characters list.`}
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/sendas name="Chloe" Hello, guys!</code></pre>
-                    will send "Hello, guys!" from "Chloe".
+                    ${t`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".
+                    ${t`will send a message as the character "Chloe", but utilizing the avatar from a character named "BigBadBoss".`}
                 </li>
             </ul>
         </div>
         <div>
-            If "compact" is set to true, the message is sent using a compact layout.
+            ${t`If "compact" is set to true, the message is sent using a compact layout.`}
         </div>
     `,
     }));

         rawQuotes: true,
         callback: sendNarratorMessage,
         aliases: ['nar'],
-        returns: 'Optionally the text of the sent message, if specified in the "return" argument',
+        returns: t`Optionally the text of the sent message, if specified in the "return" argument`,
         namedArgumentList: [
             new SlashCommandNamedArgument(
                 'compact',
-                'compact layout',
+                t`compact layout`,
                 [ARGUMENT_TYPE.BOOLEAN],
                 false,
                 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 (including -0) 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.',
+                description: t`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 (including -0) 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.`,
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'name',
-                description: 'Optional custom display name to use for this system narrator message.',
+                description: t`Optional custom display name to use for this system narrator message.`,
                 typeList: [ARGUMENT_TYPE.STRING],
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'return',
-                description: 'The way how you want the return value to be provided',
+                description: t`The way how you want the return value to be provided`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: 'none',
                 enumList: slashCommandReturnHelper.enumList({ allowObject: true }),

             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'raw',
-                description: 'If true, does not alter quoted literal unnamed arguments',
+                description: t`If true, does not alter quoted literal unnamed arguments`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'true',
                 enumProvider: commonEnumProviders.boolean('trueFalse'),

         ],
         helpString: `
         <div>
-            Sends a message as a system narrator.
+            ${t`Sends a message as a system narrator.`}
         </div>
         <div>
-            If <code>compact</code> is set to <code>true</code>, the message is sent using a compact layout.
+            ${t`If <code>compact</code> is set to <code>true</code>, the message is sent using a compact layout.`}
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/sys The sun sets in the west.</code></pre>

         callback: setNarratorName,
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'name', [ARGUMENT_TYPE.STRING], false,
+                t`name`, [ARGUMENT_TYPE.STRING], false,
             ),
         ],
-        helpString: 'Sets a name for future system narrator messages in this chat (display only). Default: System. Leave empty to reset.',
+        helpString: t`Sets a name for future system narrator messages in this chat (display only). Default: System. Leave empty to reset.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'comment',
         rawQuotes: true,
         callback: sendCommentMessage,
-        returns: 'Optionally the text of the sent message, if specified in the "return" argument',
+        returns: t`Optionally the text of the sent message, if specified in the "return" argument`,
         namedArgumentList: [
             new SlashCommandNamedArgument(
                 'compact',
-                'Whether to use a compact layout',
+                t`Whether to use a compact layout`,
                 [ARGUMENT_TYPE.BOOLEAN],
                 false,
                 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 (including -0) 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.',
+                description: t`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 (including -0) 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.`,
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'return',
-                description: 'The way how you want the return value to be provided',
+                description: t`The way how you want the return value to be provided`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: 'none',
                 enumList: slashCommandReturnHelper.enumList({ allowObject: true }),

             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'raw',
-                description: 'If true, does not alter quoted literal unnamed arguments',
+                description: t`If true, does not alter quoted literal unnamed arguments`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'true',
                 enumProvider: commonEnumProviders.boolean('trueFalse'),

         ],
         helpString: `
         <div>
-            Adds a note/comment message not part of the chat.
+            ${t`Adds a note/comment message not part of the chat.`}
         </div>
         <div>
-            If <code>compact</code> is set to <code>true</code>, the message is sent using a compact layout.
+            ${t`If <code>compact</code> is set to <code>true</code>, the message is sent using a compact layout.`}
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/comment This is a comment</code></pre>

         name: 'single',
         callback: setStoryModeCallback,
         aliases: ['story'],
-        helpString: 'Sets the message style to single document mode without names or avatars visible.',
+        helpString: t`Sets the message style to single document mode without names or avatars visible.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'bubble',
         callback: setBubbleModeCallback,
         aliases: ['bubbles'],
-        helpString: 'Sets the message style to bubble chat mode.',
+        helpString: t`Sets the message style to bubble chat mode.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'flat',
         callback: setFlatModeCallback,
         aliases: ['default'],
-        helpString: 'Sets the message style to flat chat mode.',
+        helpString: t`Sets the message style to flat chat mode.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'continue',

         namedArgumentList: [
             new SlashCommandNamedArgument(
                 'await',
-                'Whether to await for the continued generation before proceeding',
+                t`Whether to await for the continued generation before proceeding`,
                 [ARGUMENT_TYPE.BOOLEAN],
                 false,
                 false,

         ],
         helpString: `
         <div>
-            Continues the last message in the chat, with an optional additional prompt.
+            ${t`Continues the last message in the chat, with an optional additional prompt.`}
         </div>
         <div>
-            If <code>await=true</code> named argument is passed, the command will await for the continued generation before proceeding.
+            ${t`If <code>await=true</code> named argument is passed, the command will await for the continued generation before proceeding.`}
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/continue</code></pre>
-                    Continues the chat with no additional prompt and immediately proceeds to the next command.
+                    ${t`Continues the chat with no additional prompt and immediately proceeds to the next command.`}
                 </li>
                 <li>
                     <pre><code>/continue await=true Let's explore this further...</code></pre>
-                    Continues the chat with the provided prompt and waits for the generation to finish.
+                    ${t`Continues the chat with the provided prompt and waits for the generation to finish.`}
                 </li>
             </ul>
         </div>

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

             const renamed = await renameCharacter(name, { silent: isTrueBoolean(silent), renameChats: chats !== null ? isTrueBoolean(chats) : null });
             return String(renamed);
         },
-        returns: 'true/false - Whether the rename was successful',
+        returns: t`true/false - Whether the rename was successful`,
         namedArgumentList: [
             new SlashCommandNamedArgument(
-                'silent', 'Hide any blocking popups. (if false, the name is optional. If not supplied, a popup asking for it will appear)', [ARGUMENT_TYPE.BOOLEAN], false, false, 'true',
+                'silent', t`Hide any blocking popups. (if false, the name is optional. If not supplied, a popup asking for it will appear)`, [ARGUMENT_TYPE.BOOLEAN], false, false, 'true',
             ),
             new SlashCommandNamedArgument(
-                'chats', 'Rename char in all previous chats', [ARGUMENT_TYPE.BOOLEAN], false, false, '<null>',
+                'chats', t`Rename char in all previous chats`, [ARGUMENT_TYPE.BOOLEAN], false, false, '<null>',
             ),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'new char name', [ARGUMENT_TYPE.STRING], true,
+                t`new char name`, [ARGUMENT_TYPE.STRING], true,
             ),
         ],
-        helpString: 'Renames the current character.',
+        helpString: t`Renames the current character.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'sysgen',

         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'trim',
-                description: 'Trim the output by the last sentence boundary',
+                description: t`Trim the output by the last sentence boundary`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'false',
                 isRequired: false,

             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'compact',
-                description: 'Use a compact layout for the message',
+                description: t`Use a compact layout for the message`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'false',
                 isRequired: 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 (including -0) 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.',
+                description: t`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 (including -0) 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.`,
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'name',
-                description: 'Optional custom display name to use for this system narrator message.',
+                description: t`Optional custom display name to use for this system narrator message.`,
                 typeList: [ARGUMENT_TYPE.STRING],
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'return',
-                description: 'The way how you want the return value to be provided',
+                description: t`The way how you want the return value to be provided`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: 'none',
                 enumList: slashCommandReturnHelper.enumList({ allowObject: true }),

                 'prompt', [ARGUMENT_TYPE.STRING], true,
             ),
         ],
-        helpString: 'Generates a system message using a specified prompt.',
+        helpString: t`Generates a system message using a specified prompt.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'ask',
         callback: askCharacter,
-        returns: 'Optionally the text of the sent message, if specified in the "return" argument',
+        returns: t`Optionally the text of the sent message, if specified in the "return" argument`,
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'name',
-                description: 'Character name - or unique character identifier (avatar key)',
+                description: t`Character name - or unique character identifier (avatar key)`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 enumProvider: commonEnumProviders.characters('character'),
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'return',
-                description: 'The way how you want the return value to be provided',
+                description: t`The way how you want the return value to be provided`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: 'pipe',
                 enumList: slashCommandReturnHelper.enumList({ allowObject: true }),

                 'prompt', [ARGUMENT_TYPE.STRING], false, false,
             ),
         ],
-        helpString: 'Asks a specified character card a prompt. Character name must be provided in a named argument.',
+        helpString: t`Asks a specified character card a prompt. Character name must be provided in a named argument.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'delname',

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

         aliases: ['cancel'],
         helpString: `
         <div>
-            Deletes all messages attributed to a specified name.
+            ${t`Deletes all messages attributed to a specified name.`}
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/delname John</code></pre>

         name: 'send',
         rawQuotes: true,
         callback: sendUserMessageCallback,
-        returns: 'Optionally the text of the sent message, if specified in the "return" argument',
+        returns: t`Optionally the text of the sent message, if specified in the "return" argument`,
         namedArgumentList: [
             new SlashCommandNamedArgument(
                 'compact',
-                'whether to use a compact layout',
+                t`whether to use a compact layout`,
                 [ARGUMENT_TYPE.BOOLEAN],
                 false,
                 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 (including -0) 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.',
+                description: t`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 (including -0) 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.`,
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'name',
-                description: 'display name',
+                description: t`display name`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: '{{user}}',
                 enumProvider: commonEnumProviders.personas,
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'return',
-                description: 'The way how you want the return value to be provided',
+                description: t`The way how you want the return value to be provided`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: 'none',
                 enumList: slashCommandReturnHelper.enumList({ allowObject: true }),

             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'raw',
-                description: 'If true, does not alter quoted literal unnamed arguments',
+                description: t`If true, does not alter quoted literal unnamed arguments`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'true',
                 enumProvider: commonEnumProviders.boolean('trueFalse'),

         ],
         helpString: `
         <div>
-            Adds a user message to the chat log without triggering a generation.
+            ${t`Adds a user message to the chat log without triggering a generation.`}
         </div>
         <div>
-            If <code>compact</code> is set to <code>true</code>, the message is sent using a compact layout.
+            ${t`If <code>compact</code> is set to <code>true</code>, the message is sent using a compact layout.`}
         </div>
         <div>
-            If <code>name</code> is set, it will be displayed as the message sender. Can be an empty for no name.
+            ${t`If <code>name</code> is set, it will be displayed as the message sender. Can be an empty for no name.`}
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/send Hello there!</code></pre>

         namedArgumentList: [
             new SlashCommandNamedArgument(
                 'await',
-                'Whether to await for the triggered generation before continuing',
+                t`Whether to await for the triggered generation before continuing`,
                 [ARGUMENT_TYPE.BOOLEAN],
                 false,
                 false,

         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'group member index (starts with 0) or name',
+                description: t`group member index (starts with 0) or name`,
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.STRING],
                 isRequired: false,
                 enumProvider: commonEnumProviders.groupMembers(),

         ],
         helpString: `
         <div>
-            Triggers a message generation. If in group, can trigger a message for the specified group member index or name.
+            ${t`Triggers a message generation. If in group, can trigger a message for the specified group member index or name.`}
         </div>
         <div>
-            If <code>await=true</code> named argument is passed, the command will await for the triggered generation before continuing.
+            ${t`If <code>await=true</code> named argument is passed, the command will await for the triggered generation before continuing.`}
         </div>
     `,
     }));

         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'name',
-                description: 'only hide messages from a certain character or persona',
+                description: t`only hide messages from a certain character or persona`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 enumProvider: commonEnumProviders.messageNames,
                 isRequired: false,

         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'message index (starts with 0) or range, defaults to the last message index if not provided',
+                description: t`message index (starts with 0) or range, defaults to the last message index if not provided`,
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.RANGE],
                 isRequired: false,
                 enumProvider: commonEnumProviders.messages(),
             }),
         ],
-        helpString: 'Hides a chat message from the prompt.',
+        helpString: t`Hides a chat message from the prompt.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'unhide',

         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'name',
-                description: 'only unhide messages from a certain character or persona',
+                description: t`only unhide messages from a certain character or persona`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 enumProvider: commonEnumProviders.messageNames,
                 isRequired: false,

         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'message index (starts with 0) or range, defaults to the last message index if not provided',
+                description: t`message index (starts with 0) or range, defaults to the last message index if not provided`,
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.RANGE],
                 isRequired: false,
                 enumProvider: commonEnumProviders.messages(),
             }),
         ],
-        helpString: 'Unhides a message from the prompt.',
+        helpString: t`Unhides a message from the prompt.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'member-get',
         aliases: ['getmember', 'memberget'],
         callback: (async ({ field = 'name' }, arg) => {
             if (!selected_group) {
-                toastr.warning('Cannot run /member-get command outside of a group chat.');
+                toastr.warning(t`Cannot run /member-get command outside of a group chat.`);
                 return '';
+            }
             if (field === '') {
-                toastr.warning('\'/member-get field=\' argument required!');
+                toastr.warning(t`'/member-get field=' argument required!`);
                 return '';
+            }
             field = field.toString();
             arg = arg.toString();
             if (!['name', 'index', 'id', 'avatar'].includes(field)) {
-                toastr.warning('\'/member-get field=\' argument required!');
+                toastr.warning(t`'/member-get field=' argument required!`);
                 return '';
+            }
             const isId = !isNaN(parseInt(arg));
             const groupMember = findGroupMemberId(arg, true);
             if (!groupMember) {
-                toastr.warning(`No group member found using ${isId ? 'id' : 'string'} ${arg}`);
+                toastr.warning(t`No group member found using ${isId ? 'id' : 'string'} ${arg}`);
                 return '';
+            }
             return groupMember[field];

         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'field',
-                description: 'Whether to retrieve the name, index, id, or avatar.',
+                description: t`Whether to retrieve the name, index, id, or avatar.`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 defaultValue: 'name',
                 enumList: [
-                    new SlashCommandEnumValue('name', 'Character name'),
+                    new SlashCommandEnumValue('name', t`Character name`),
-                    new SlashCommandEnumValue('index', 'Group member index'),
+                    new SlashCommandEnumValue('index', t`Group member index`),
-                    new SlashCommandEnumValue('avatar', 'Character avatar'),
+                    new SlashCommandEnumValue('avatar', t`Character avatar`),
-                    new SlashCommandEnumValue('id', 'Character index'),
+                    new SlashCommandEnumValue('id', t`Character index`),
                 ],
             }),
         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'member index (starts with 0), name, or avatar',
+                description: t`member index (starts with 0), name, or avatar`,
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 enumProvider: commonEnumProviders.groupMembers(),
             }),
         ],
-        helpString: 'Retrieves a group member\'s name, index, id, or avatar.',
+        helpString: t`Retrieves a group member's name, index, id, or avatar.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'member-disable',

         aliases: ['disable', 'disablemember', 'memberdisable'],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'member index (starts with 0) or name',
+                description: t`member index (starts with 0) or name`,
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 enumProvider: commonEnumProviders.groupMembers(),
             }),
         ],
-        helpString: 'Disables a group member from being drafted for replies.',
+        helpString: t`Disables a group member from being drafted for replies.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'member-enable',

         callback: enableGroupMemberCallback,
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'member index (starts with 0) or name',
+                description: t`member index (starts with 0) or name`,
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 enumProvider: commonEnumProviders.groupMembers(),
             }),
         ],
-        helpString: 'Enables a group member to be drafted for replies.',
+        helpString: t`Enables a group member to be drafted for replies.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'member-add',

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

         ],
         helpString: `
         <div>
-            Adds a new group member to the group chat.
+            ${t`Adds a new group member to the group chat.`}
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/member-add John Doe</code></pre>

         aliases: ['removemember', 'memberremove'],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'member index (starts with 0) or name',
+                description: t`member index (starts with 0) or name`,
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 enumProvider: commonEnumProviders.groupMembers(),

         ],
         helpString: `
         <div>
-            Removes a group member from the group chat.
+            ${t`Removes a group member from the group chat.`}
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/member-remove 2</code></pre>

         aliases: ['upmember', 'memberup'],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'member index (starts with 0) or name',
+                description: t`member index (starts with 0) or name`,
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 enumProvider: commonEnumProviders.groupMembers(),
             }),
         ],
-        helpString: 'Moves a group member up in the group chat list.',
+        helpString: t`Moves a group member up in the group chat list.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'member-down',

         aliases: ['downmember', 'memberdown'],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'member index (starts with 0) or name',
+                description: t`member index (starts with 0) or name`,
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 enumProvider: commonEnumProviders.groupMembers(),
             }),
         ],
-        helpString: 'Moves a group member down in the group chat list.',
+        helpString: t`Moves a group member down in the group chat list.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'member-peek',

         callback: peekCallback,
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'member index (starts with 0) or name',
+                description: t`member index (starts with 0) or name`,
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 enumProvider: commonEnumProviders.groupMembers(),

         ],
         helpString: `
         <div>
-            Shows a group member character card without switching chats.
+            ${t`Shows a group member character card without switching chats.`}
         </div>
         <div>
-            <strong>Examples:</strong>
+            <strong>${t`Examples:`}</strong>
             <ul>
                 <li>
                     <pre><code>/peek Gloria</code></pre>
-                    Shows the character card for the character named "Gloria".
+                    ${t`Shows the character card for the character named "Gloria".`}
                 </li>
             </ul>
         </div>

         name: 'member-count',
         callback: countGroupMemberCallback,
         aliases: ['countmember', 'membercount'],
-        helpString: 'Returns the total number of group members in the group chat list.',
+        helpString: t`Returns the total number of group members in the group chat list.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'delswipe',
         callback: deleteSwipeCallback,
-        returns: 'the new, currently selected swipe id',
+        returns: t`the new, currently selected swipe id`,
         aliases: ['swipedel'],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: '1-based swipe id',
+                description: t`1-based swipe id`,
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 isRequired: true,
                 enumProvider: () => Array.isArray(chat[chat.length - 1]?.swipes) ?

         ],
         helpString: `
         <div>
-            Deletes a swipe from the last chat message. If swipe id is not provided, it deletes the current swipe.
+            ${t`Deletes a swipe from the last chat message. If swipe id is not provided, it deletes the current swipe.`}
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/delswipe</code></pre>
-                    Deletes the current swipe.
+                    ${t`Deletes the current swipe.`}
                 </li>
                 <li>
                     <pre><code>/delswipe 2</code></pre>
-                    Deletes the second swipe from the last chat message.
+                    ${t`Deletes the second swipe from the last chat message.`}
                 </li>
             </ul>
         </div>

         name: 'echo',
         rawQuotes: true,
         callback: echoCallback,
-        returns: 'the text',
+        returns: t`the text`,
         namedArgumentList: [
             new SlashCommandNamedArgument(
-                'title', 'title of the toast message', [ARGUMENT_TYPE.STRING], false,
+                'title', t`title of the toast message`, [ARGUMENT_TYPE.STRING], false,
             ),
             SlashCommandNamedArgument.fromProps({
                 name: 'severity',
-                description: 'severity level of the toast message',
+                description: t`severity level of the toast message`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: 'info',
                 enumProvider: () => [

             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'timeout',
-                description: 'time in milliseconds to display the toast message. Set this and \'extendedTimeout\' to 0 to show indefinitely until dismissed.',
+                description: t`time in milliseconds to display the toast message. Set this and 'extendedTimeout' to 0 to show indefinitely until dismissed.`,
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 defaultValue: `${toastr.options.timeOut}`,
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'extendedTimeout',
-                description: 'time in milliseconds to display the toast message. Set this and \'timeout\' to 0 to show indefinitely until dismissed.',
+                description: t`time in milliseconds to display the toast message. Set this and 'timeout' to 0 to show indefinitely until dismissed.`,
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 defaultValue: `${toastr.options.extendedTimeOut}`,
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'preventDuplicates',
-                description: 'prevent duplicate toasts with the same message from being displayed.',
+                description: t`prevent duplicate toasts with the same message from being displayed.`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'false',
                 enumList: commonEnumProviders.boolean('trueFalse')(),
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'awaitDismissal',
-                description: 'wait for the toast to be dismissed before continuing.',
+                description: t`wait for the toast to be dismissed before continuing.`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'false',
                 enumList: commonEnumProviders.boolean('trueFalse')(),
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'cssClass',
-                description: 'additional CSS class to add to the toast message (e.g. for custom styling)',
+                description: t`additional CSS class to add to the toast message (e.g. for custom styling)`,
                 typeList: [ARGUMENT_TYPE.STRING],
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'color',
-                description: 'custom CSS color of the toast message. Accepts all valid CSS color values (e.g. \'red\', \'#FF0000\', \'rgb(255, 0, 0)\').<br />>Can be more customizable with the \'cssClass\' argument and custom classes.',
+                description: t`custom CSS color of the toast message. Accepts all valid CSS color values (e.g. 'red', '#FF0000', 'rgb(255, 0, 0)').<br />>Can be more customizable with the 'cssClass' argument and custom classes.`,
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'escapeHtml',
-                description: 'whether to escape HTML in the toast message.',
+                description: t`whether to escape HTML in the toast message.`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'true',
                 enumList: commonEnumProviders.boolean('trueFalse')(),
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'onClick',
-                description: 'a closure to call when the toast is clicked. This executed closure receives scope as provided in the script. Careful about possible side effects when manipulating variables and more.',
+                description: t`a closure to call when the toast is clicked. This executed closure receives scope as provided in the script. Careful about possible side effects when manipulating variables and more.`,
                 typeList: [ARGUMENT_TYPE.CLOSURE],
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'raw',
-                description: 'If true, does not alter quoted literal unnamed arguments',
+                description: t`If true, does not alter quoted literal unnamed arguments`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'true',
                 enumProvider: commonEnumProviders.boolean('trueFalse'),

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'gen',
         callback: generateCallback,
-        returns: 'generated text',
+        returns: t`generated text`,
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'trim',
-                description: 'Trim the output by the last sentence boundary',
+                description: t`Trim the output by the last sentence boundary`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'false',
                 isRequired: false,
                 enumProvider: commonEnumProviders.boolean('trueFalse'),
             }),
             new SlashCommandNamedArgument(
-                'lock', 'lock user input during generation', [ARGUMENT_TYPE.BOOLEAN], false, false, null, commonEnumProviders.boolean('onOff')(),
+                'lock', t`lock user input during generation`, [ARGUMENT_TYPE.BOOLEAN], false, false, null, commonEnumProviders.boolean('onOff')(),
             ),
             SlashCommandNamedArgument.fromProps({
                 name: 'name',
-                description: 'in-prompt character name for instruct mode (or unique character identifier (avatar key), which will be used as name)',
+                description: t`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)],
             }),
             new SlashCommandNamedArgument(
-                'length', 'API response length in tokens', [ARGUMENT_TYPE.NUMBER], false,
+                'length', t`API response length in tokens`, [ARGUMENT_TYPE.NUMBER], false,
             ),
             SlashCommandNamedArgument.fromProps({
                 name: 'as',
-                description: 'role of the output prompt',
+                description: t`role of the output prompt`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 enumList: [
                     new SlashCommandEnumValue('system', null, enumTypes.enum, enumIcons.assistant),

         ],
         helpString: `
         <div>
-            Generates text using the provided prompt and passes it to the next command through the pipe, optionally locking user input while generating and allowing to configure the in-prompt name for instruct mode (default = "System").
+            ${t`Generates text using the provided prompt and passes it to the next command through the pipe, optionally locking user input while generating and allowing to configure the in-prompt name for instruct mode (default = "System").`}
         </div>
         <div>
-            "as" argument controls the role of the output prompt: system (default) or char. If "length" argument is provided as a number in tokens, allows to temporarily override an API response length.
+            ${t`"as" argument controls the role of the output prompt: system (default) or char. If "length" argument is provided as a number in tokens, allows to temporarily override an API response length.`}
         </div>
     `,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'genraw',
         callback: generateRawCallback,
-        returns: 'generated text',
+        returns: t`generated text`,
         namedArgumentList: [
             new SlashCommandNamedArgument(
-                'lock', 'lock user input during generation', [ARGUMENT_TYPE.BOOLEAN], false, false, 'off', commonEnumProviders.boolean('onOff')(),
+                'lock', t`lock user input during generation`, [ARGUMENT_TYPE.BOOLEAN], false, false, 'off', commonEnumProviders.boolean('onOff')(),
             ),
             new SlashCommandNamedArgument(
-                'instruct', 'use instruct mode', [ARGUMENT_TYPE.BOOLEAN], false, false, 'on', commonEnumProviders.boolean('onOff')(),
+                'instruct', t`use instruct mode`, [ARGUMENT_TYPE.BOOLEAN], false, false, 'on', commonEnumProviders.boolean('onOff')(),
             ),
             new SlashCommandNamedArgument(
-                'stop', 'one-time custom stop strings', [ARGUMENT_TYPE.LIST], false, false, '[]',
+                'stop', t`one-time custom stop strings`, [ARGUMENT_TYPE.LIST], false, false, '[]',
             ),
             SlashCommandNamedArgument.fromProps({
                 name: 'as',
-                description: 'role of the output prompt',
+                description: t`role of the output prompt`,
                 defaultValue: 'system',
                 typeList: [ARGUMENT_TYPE.STRING],
                 enumList: [

                 ],
             }),
             new SlashCommandNamedArgument(
-                'system', 'system prompt at the start', [ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.VARIABLE_NAME], false,
+                'system', t`system prompt at the start`, [ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.VARIABLE_NAME], false,
             ),
             new SlashCommandNamedArgument(
-                'prefill', 'prefill prompt at the end', [ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.VARIABLE_NAME], false,
+                'prefill', t`prefill prompt at the end`, [ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.VARIABLE_NAME], false,
             ),
             new SlashCommandNamedArgument(
-                'length', 'API response length in tokens', [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME], false,
+                'length', t`API response length in tokens`, [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME], false,
             ),
             new SlashCommandNamedArgument(
-                'trim', 'trim {{user}} and {{char}} prefixes from the output', [ARGUMENT_TYPE.BOOLEAN], false, false, 'on', commonEnumProviders.boolean('onOff')(),
+                'trim', t`trim {{user}} and {{char}} prefixes from the output`, [ARGUMENT_TYPE.BOOLEAN], false, false, 'on', commonEnumProviders.boolean('onOff')(),
             ),
         ],
         unnamedArgumentList: [

         ],
         helpString: `
         <div>
-            Generates text using the provided prompt and passes it to the next command through the pipe, optionally locking user input while generating. Does not include chat history or character card.
+            ${t`Generates text using the provided prompt and passes it to the next command through the pipe, optionally locking user input while generating. Does not include chat history or character card.`}
         </div>
         <div>
-            Use instruct=off to skip instruct formatting, e.g. <pre><code>/genraw instruct=off Why is the sky blue?</code></pre>
+            ${t`Use instruct=off to skip instruct formatting, e.g. <pre><code>/genraw instruct=off Why is the sky blue?</code></pre>`}
         </div>
         <div>
-            Use stop=... with a JSON-serialized array to add one-time custom stop strings, e.g. <pre><code>/genraw stop=["\\n"] Say hi</code></pre>
+            ${t`Use stop=... with a JSON-serialized array to add one-time custom stop strings, e.g. <pre><code>/genraw stop=["\\n"] Say hi</code></pre>`}
         </div>
         <div>
-            "as" argument controls the role of the output prompt: system (default) or char. "system" argument adds an (optional) system prompt at the start.
+            ${t`"as" argument controls the role of the output prompt: system (default) or char. "system" argument adds an (optional) system prompt at the start.`}
         </div>
         <div>
-            If "length" argument is provided as a number in tokens, allows to temporarily override an API response length.
+            ${t`If "length" argument is provided as a number in tokens, allows to temporarily override an API response length.`}
         </div>
     `,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'addswipe',
         callback: addSwipeCallback,
-        returns: 'the new swipe id',
+        returns: t`the new swipe id`,
         aliases: ['swipeadd'],
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'switch',
-                description: 'switch to the new swipe',
+                description: t`switch to the new swipe`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 enumList: commonEnumProviders.boolean()(),
             }),

         ],
         helpString: `
         <div>
-            Adds a swipe to the last chat message.
+            ${t`Adds a swipe to the last chat message.`}
         </div>
         <div>
-            Use switch=true to switch to directly switch to the new swipe.
+            ${t`Use switch=true to switch to directly switch to the new swipe.`}
         </div>`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({

             const stopped = stopGeneration();
             return String(stopped);
         },
-        returns: 'true/false, whether the generation was running and got stopped',
+        returns: t`true/false, whether the generation was running and got stopped`,
         helpString: `
             <div>
-                Stops the generation and any streaming if it is currently running.
+                ${t`Stops the generation and any streaming if it is currently running.`}
             </div>
             <div>
-                Note: This command cannot be executed from the chat input, as sending any message or script from there is blocked during generation.
+                ${t`Note: This command cannot be executed from the chat input, as sending any message or script from there is blocked during generation. But it can be executed via automations or QR scripts/buttons.`}
-                But it can be executed via automations or QR scripts/buttons.
             </div>
         `,
         aliases: ['generate-stop'],

         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'quiet',
-                description: 'Whether to suppress the toast message notifying about the /abort call.',
+                description: t`Whether to suppress the toast message notifying about the /abort call.`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'true',
             }),
         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'The reason for aborting command execution. Shown when quiet=false',
+                description: t`The reason for aborting command execution. Shown when quiet=false`,
                 typeList: [ARGUMENT_TYPE.STRING],
             }),
         ],
-        helpString: 'Aborts the slash command batch execution.',
+        helpString: t`Aborts the slash command batch execution.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'fuzzy',
         callback: fuzzyCallback,
-        returns: 'matching item',
+        returns: t`matching item`,
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'list',
-                description: 'list of items to match against',
+                description: t`list of items to match against`,
                 acceptsMultiple: false,
                 isRequired: true,
                 typeList: [ARGUMENT_TYPE.LIST, ARGUMENT_TYPE.VARIABLE_NAME],

             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'threshold',
-                description: 'fuzzy match threshold (0.0 to 1.0)',
+                description: t`fuzzy match threshold (0.0 to 1.0)`,
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 isRequired: false,
                 defaultValue: '0.4',

             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'mode',
-                description: 'fuzzy match mode',
+                description: t`fuzzy match mode`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: false,
                 defaultValue: 'first',
                 acceptsMultiple: false,
                 enumList: [
-                    new SlashCommandEnumValue('first', 'first match below the threshold', enumTypes.enum, enumIcons.default),
+                    new SlashCommandEnumValue('first', t`first match below the threshold`, enumTypes.enum, enumIcons.default),
-                    new SlashCommandEnumValue('best', 'best match below the threshold', enumTypes.enum, enumIcons.default),
+                    new SlashCommandEnumValue('best', t`best match below the threshold`, enumTypes.enum, enumIcons.default),
                 ],
             }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'text to search', [ARGUMENT_TYPE.STRING], true,
+                t`text to search`, [ARGUMENT_TYPE.STRING], true,
             ),
         ],
         helpString: `
         <div>
-            Performs a fuzzy match of each item in the <code>list</code> against the <code>text to search</code>.
+            ${t`Performs a fuzzy match of each item in the <code>list</code> against the <code>text to search</code>. If any item matches, then its name is returned. If no item matches the text, no value is returned.`}
-            If any item matches, then its name is returned. If no item matches the text, no value is returned.
         </div>
         <div>
-            The optional <code>threshold</code> (default is 0.4) allows control over the match strictness.
+            ${t`The optional <code>threshold</code> (default is 0.4) allows control over the match strictness.`}
-            A low value (min 0.0) means the match is very strict.
+            ${t`A low value (min 0.0) means the match is very strict.`}
-            At 1.0 (max) the match is very loose and will match anything.
+            ${t`At 1.0 (max) the match is very loose and will match anything.`}
         </div>
         <div>
-            The optional <code>mode</code> argument allows to control the behavior when multiple items match the text.
+            ${t`The optional <code>mode</code> argument allows to control the behavior when multiple items match the text.`}
             <ul>
-                <li><code>first</code> (default) returns the first match below the threshold.</li>
+                <li>${t`<code>first</code> (default) returns the first match below the threshold.`}</li>
-                <li><code>best</code> returns the best match below the threshold.</li>
+                <li>${t`<code>best</code> returns the best match below the threshold.`}</li>
             </ul>
         </div>
         <div>
-            The returned value passes to the next command through the pipe.
+            ${t`The returned value passes to the next command through the pipe.`}
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/fuzzy list=["a","b","c"] threshold=0.4 abc</code></pre>

         name: 'pass',
         callback: (_, arg) => {
             // We do not support arrays of closures. Arrays of strings will be send as JSON
-            if (Array.isArray(arg) && arg.some(x => x instanceof SlashCommandClosure)) throw new Error('Command /pass does not support multiple closures');
+            if (Array.isArray(arg) && arg.some(x => x instanceof SlashCommandClosure)) throw new Error(t`Command /pass does not support multiple closures`);
             if (Array.isArray(arg)) return JSON.stringify(arg);
             return arg;
         },
-        returns: 'the provided value',
+        returns: t`the provided value`,
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'text', [ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.BOOLEAN, ARGUMENT_TYPE.LIST, ARGUMENT_TYPE.DICTIONARY, ARGUMENT_TYPE.CLOSURE], true,
+                t`text`, [ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.BOOLEAN, ARGUMENT_TYPE.LIST, ARGUMENT_TYPE.DICTIONARY, ARGUMENT_TYPE.CLOSURE], true,
             ),
         ],
         aliases: ['return'],
         helpString: `
         <div>
-            <pre><span class="monospace">/pass (text)</span> – passes the text to the next command through the pipe.</pre>
+            <pre><span class="monospace">/pass (text)</span> – ${t`passes the text to the next command through the pipe.`}</pre>
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li><pre><code>/pass Hello world</code></pre></li>
             </ul>

         aliases: ['wait', 'sleep'],
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'milliseconds', [ARGUMENT_TYPE.NUMBER], true,
+                t`milliseconds`, [ARGUMENT_TYPE.NUMBER], true,
             ),
         ],
         helpString: `
         <div>
-            Delays the next command in the pipe by the specified number of milliseconds.
+            ${t`Delays the next command in the pipe by the specified number of milliseconds.`}
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/delay 1000</code></pre>

         name: 'input',
         aliases: ['prompt'],
         callback: inputCallback,
-        returns: 'user input',
+        returns: t`user input`,
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'default',
-                description: 'default value of the input field',
+                description: t`default value of the input field`,
                 typeList: [ARGUMENT_TYPE.STRING],
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'large',
-                description: 'popup window will be shown larger in height, with more space for content (input field needs to be sized via \'rows\' argument)',
+                description: t`popup window will be shown larger in height, with more space for content (input field needs to be sized via 'rows' argument)`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'off',
                 enumList: commonEnumProviders.boolean('onOff')(),
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'wide',
-                description: 'popup window will be shown wider, with a wider input field',
+                description: t`popup window will be shown wider, with a wider input field`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'off',
                 enumList: commonEnumProviders.boolean('onOff')(),
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'okButton',
-                description: 'text for the ok button',
+                description: t`text for the ok button`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: 'Ok',
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'rows',
-                description: 'number of rows for the input field (lines being displayed)',
+                description: t`number of rows for the input field (lines being displayed)`,
                 typeList: [ARGUMENT_TYPE.NUMBER],
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'onSuccess',
-                description: 'closure to execute when the ok button is clicked or the input is closed as successful (via Enter, etc)',
+                description: t`closure to execute when the ok button is clicked or the input is closed as successful (via Enter, etc)`,
                 typeList: [ARGUMENT_TYPE.CLOSURE],
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'onCancel',
-                description: 'closure to execute when the cancel button is clicked or the input is closed as cancelled (via Escape, etc)',
+                description: t`closure to execute when the cancel button is clicked or the input is closed as cancelled (via Escape, etc)`,
                 typeList: [ARGUMENT_TYPE.CLOSURE],
             }),
         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'text to display',
+                description: t`text to display`,
                 typeList: [ARGUMENT_TYPE.STRING],
             }),
         ],
         helpString: `
         <div>
-            Shows a popup with the provided text and an input field.
+            ${t`Shows a popup with the provided text and an input field.`}
-            The <code>default</code> argument is the default value of the input field, and the text argument is the text to display.
+            ${t`The <code>default</code> argument is the default value of the input field, and the text argument is the text to display.`}
         </div>
     `,
     }));

         name: 'run',
         aliases: ['call', 'exec'],
         callback: runCallback,
-        returns: 'result of the executed closure of QR',
+        returns: t`result of the executed closure of QR`,
         namedArgumentList: [
             new SlashCommandNamedArgument(
-                'args', 'named arguments', [ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.BOOLEAN, ARGUMENT_TYPE.LIST, ARGUMENT_TYPE.DICTIONARY], false, true,
+                'args', t`named arguments`, [ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.BOOLEAN, ARGUMENT_TYPE.LIST, ARGUMENT_TYPE.DICTIONARY], false, true,
             ),
         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'scoped variable or qr label',
+                description: t`scoped variable or qr label`,
                 typeList: [ARGUMENT_TYPE.VARIABLE_NAME, ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.CLOSURE],
                 isRequired: true,
                 enumProvider: (executor, scope) => [

         ],
         helpString: `
         <div>
-            Runs a closure from a scoped variable, or a Quick Reply with the specified name from a currently active preset or from another preset.
+            ${t`Runs a closure from a scoped variable, or a Quick Reply with the specified name from a currently active preset or from another preset.`}
-            Named arguments can be referenced in a QR with <code>{{arg::key}}</code>.
+            ${t`Named arguments can be referenced in a QR with <code>{{arg::key}}</code>.`}
         </div>
     `,
     }));

         aliases: ['message'],
         namedArgumentList: [
             new SlashCommandNamedArgument(
-                'names', 'show message author names', [ARGUMENT_TYPE.BOOLEAN], false, false, 'off', commonEnumProviders.boolean('onOff')(),
+                'names', t`show message author names`, [ARGUMENT_TYPE.BOOLEAN], false, false, 'off', commonEnumProviders.boolean('onOff')(),
             ),
             new SlashCommandNamedArgument(
-                'hidden', 'include hidden messages', [ARGUMENT_TYPE.BOOLEAN], false, false, 'on', commonEnumProviders.boolean('onOff')(),
+                'hidden', t`include hidden messages`, [ARGUMENT_TYPE.BOOLEAN], false, false, 'on', commonEnumProviders.boolean('onOff')(),
             ),
             SlashCommandNamedArgument.fromProps({
                 name: 'role',
-                description: 'filter messages by role',
+                description: t`filter messages by role`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 enumList: [
                     new SlashCommandEnumValue('system', null, enumTypes.enum, enumIcons.system),

         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'message index (starts with 0) or range',
+                description: t`message index (starts with 0) or range`,
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.RANGE],
                 isRequired: true,
                 enumProvider: commonEnumProviders.messages(),
             }),
         ],
-        returns: 'the specified message or range of messages as a string',
+        returns: t`the specified message or range of messages as a string`,
         helpString: `
         <div>
-            Returns the specified message or range of messages as a string.
+            ${t`Returns the specified message or range of messages as a string.`}
         </div>
         <div>
-            Use the <code>hidden=off</code> argument to exclude hidden messages.
+            ${t`Use the <code>hidden=off</code> argument to exclude hidden messages.`}
         </div>
         <div>
-            Use the <code>role</code> argument to filter messages by role. Possible values are: system, assistant, user.
+            ${t`Use the <code>role</code> argument to filter messages by role. Possible values are: system, assistant, user.`}
         </div>
         <div>
-            <strong>Examples:</strong>
+            <strong>${t`Examples:`}</strong>
             <ul>
                 <li>
                     <pre><code>/messages 10</code></pre>
-                    Returns the 10th message.
+                    ${t`Returns the 10th message.`}
                 </li>
                 <li>
                     <pre><code>/messages names=on 5-10</code></pre>
-                    Returns messages 5 through 10 with author names.
+                    ${t`Returns messages 5 through 10 with author names.`}
                 </li>
             </ul>
         </div>

         callback: setInputCallback,
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'text', [ARGUMENT_TYPE.STRING], true,
+                t`text`, [ARGUMENT_TYPE.STRING], true,
             ),
         ],
         helpString: `
         <div>
-            Sets the user input to the specified text and passes it to the next command through the pipe.
+            ${t`Sets the user input to the specified text and passes it to the next command through the pipe.`}
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/setinput Hello world</code></pre>

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'popup',
         callback: popupCallback,
-        returns: 'popup text',
+        returns: t`popup text`,
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'scroll',
-                description: 'allows vertical scrolling of the content',
+                description: t`allows vertical scrolling of the content`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 enumList: commonEnumProviders.boolean('trueFalse')(),
                 defaultValue: 'true',
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'large',
-                description: 'show large popup',
+                description: t`show large popup`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 enumList: commonEnumProviders.boolean('trueFalse')(),
                 defaultValue: 'false',
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'wide',
-                description: 'show wide popup',
+                description: t`show wide popup`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 enumList: commonEnumProviders.boolean('trueFalse')(),
                 defaultValue: 'false',
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'wider',
-                description: 'show wider popup',
+                description: t`show wider popup`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 enumList: commonEnumProviders.boolean('trueFalse')(),
                 defaultValue: 'false',
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'transparent',
-                description: 'show transparent popup',
+                description: t`show transparent popup`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 enumList: commonEnumProviders.boolean('trueFalse')(),
                 defaultValue: 'false',
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'okButton',
-                description: 'text for the OK button',
+                description: t`text for the OK button`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: 'OK',
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'cancelButton',
-                description: 'text for the Cancel button',
+                description: t`text for the Cancel button`,
                 typeList: [ARGUMENT_TYPE.STRING],
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'result',
-                description: 'if enabled, returns the popup result (as an integer) instead of the popup text. Resolves to 1 for OK and 0 cancel button, empty string for exiting out.',
+                description: t`if enabled, returns the popup result (as an integer) instead of the popup text. Resolves to 1 for OK and 0 cancel button, empty string for exiting out.`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 enumList: commonEnumProviders.boolean('trueFalse')(),
                 defaultValue: 'false',

         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'popup text',
+                description: t`popup text`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
             }),
         ],
         helpString: `
         <div>
-            Shows a blocking popup with the specified text and buttons.
+            ${t`Shows a blocking popup with the specified text and buttons.`}
-            Returns the popup text.
+            ${t`Returns the popup text.`}
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/popup large=on wide=on okButton="Confirm" Please confirm this action.</code></pre>

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'buttons',
         callback: buttonsCallback,
-        returns: 'clicked button label (or array of labels if multiple is enabled)',
+        returns: t`clicked button label (or array of labels if multiple is enabled)`,
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'labels',
-                description: 'button labels',
+                description: t`button labels`,
                 typeList: [ARGUMENT_TYPE.LIST],
                 isRequired: true,
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'multiple',
-                description: 'if enabled multiple buttons can be clicked/toggled, and all clicked buttons are returned as an array',
+                description: t`if enabled multiple buttons can be clicked/toggled, and all clicked buttons are returned as an array`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 enumList: commonEnumProviders.boolean('trueFalse')(),
                 defaultValue: 'false',

         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'text',
+                description: t`text`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
             }),
         ],
         helpString: `
         <div>
-            Shows a blocking popup with the specified text and buttons.
+            ${t`Shows a blocking popup with the specified text and buttons.`}
-            Returns the clicked button label into the pipe or empty string if canceled.
+            ${t`Returns the clicked button label into the pipe or empty string if canceled.`}
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/buttons labels=["Yes","No"] Do you want to continue?</code></pre>

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'trimtokens',
         callback: trimTokensCallback,
-        returns: 'trimmed text',
+        returns: t`trimmed text`,
         namedArgumentList: [
             new SlashCommandNamedArgument(
-                'limit', 'number of tokens to keep', [ARGUMENT_TYPE.NUMBER], true,
+                'limit', t`number of tokens to keep`, [ARGUMENT_TYPE.NUMBER], true,
             ),
             SlashCommandNamedArgument.fromProps({
                 name: 'direction',
-                description: 'trim direction',
+                description: t`trim direction`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 enumList: [

         ],
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'text', [ARGUMENT_TYPE.STRING], false,
+                t`text`, [ARGUMENT_TYPE.STRING], false,
             ),
         ],
         helpString: `
         <div>
-            Trims the start or end of text to the specified number of tokens.
+            ${t`Trims the start or end of text to the specified number of tokens.`}
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/trimtokens limit=5 direction=start This is a long sentence with many words</code></pre>

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'trimstart',
         callback: trimStartCallback,
-        returns: 'trimmed text',
+        returns: t`trimmed text`,
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'text', [ARGUMENT_TYPE.STRING], true,
+                t`text`, [ARGUMENT_TYPE.STRING], true,
             ),
         ],
         helpString: `
         <div>
-            Trims the text to the start of the first full sentence.
+            ${t`Trims the text to the start of the first full sentence.`}
         </div>
         <div>
-            <strong>Example:</strong>
+            <strong>${t`Example:`}</strong>
             <ul>
                 <li>
                     <pre><code>/trimstart This is a sentence. And here is another sentence.</code></pre>

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'trimend',
         callback: trimEndCallback,
-        returns: 'trimmed text',
+        returns: t`trimmed text`,
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'text', [ARGUMENT_TYPE.STRING], true,
+                t`text`, [ARGUMENT_TYPE.STRING], true,
             ),
         ],
-        helpString: 'Trims the text to the end of the last full sentence.',
+        helpString: t`Trims the text to the end of the last full sentence.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'inject',
-        returns: 'injection ID',
+        returns: t`injection ID`,
         callback: injectCallback,
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'id',
-                description: 'injection ID',
+                description: t`injection ID`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: false,
                 enumProvider: commonEnumProviders.injects,
             }),
             new SlashCommandNamedArgument(
-                'position', 'injection position', [ARGUMENT_TYPE.STRING], false, false, 'after', ['before', 'after', 'chat', 'none'],
+                'position', t`injection position`, [ARGUMENT_TYPE.STRING], false, false, 'after', ['before', 'after', 'chat', 'none'],
             ),
             new SlashCommandNamedArgument(
-                'depth', 'injection depth', [ARGUMENT_TYPE.NUMBER], false, false, '4',
+                'depth', t`injection depth`, [ARGUMENT_TYPE.NUMBER], false, false, '4',
             ),
             new SlashCommandNamedArgument(
-                'scan', 'include injection content into World Info scans', [ARGUMENT_TYPE.BOOLEAN], false, false, 'false',
+                'scan', t`include injection content into World Info scans`, [ARGUMENT_TYPE.BOOLEAN], false, false, 'false',
             ),
             SlashCommandNamedArgument.fromProps({
                 name: 'role',
-                description: 'role for in-chat injections',
+                description: t`role for in-chat injections`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: false,
                 enumList: [

                 ],
             }),
             new SlashCommandNamedArgument(
-                'ephemeral', 'remove injection after generation', [ARGUMENT_TYPE.BOOLEAN], false, false, 'false',
+                'ephemeral', t`remove injection after generation`, [ARGUMENT_TYPE.BOOLEAN], false, false, 'false',
             ),
             SlashCommandNamedArgument.fromProps({
                 name: 'filter',
-                description: 'if a filter is defined, an injection will only be performed if the closure returns true',
+                description: t`if a filter is defined, an injection will only be performed if the closure returns true`,
                 typeList: [ARGUMENT_TYPE.CLOSURE],
                 isRequired: false,
                 acceptsMultiple: false,

         ],
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'text', [ARGUMENT_TYPE.STRING], false,
+                t`text`, [ARGUMENT_TYPE.STRING], false,
             ),
         ],
-        helpString: 'Injects a text into the LLM prompt for the current chat. Requires a unique injection ID (will be auto-generated if not provided). Positions: "before" main prompt, "after" main prompt, in-"chat", hidden with "none" (default: after). Depth: injection depth for the prompt (default: 4). Role: role for in-chat injections (default: system). Scan: include injection content into World Info scans (default: false). Hidden injects in "none" position are not inserted into the prompt but can be used for triggering WI entries. Returns the injection ID.',
+        helpString: t`Injects a text into the LLM prompt for the current chat. Requires a unique injection ID (will be auto-generated if not provided). Positions: "before" main prompt, "after" main prompt, in-"chat", hidden with "none" (default: after). Depth: injection depth for the prompt (default: 4). Role: role for in-chat injections (default: system). Scan: include injection content into World Info scans (default: false). Hidden injects in "none" position are not inserted into the prompt but can be used for triggering WI entries. Returns the injection ID.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'listinjects',
         callback: listInjectsCallback,
-        helpString: 'Lists all script injections for the current chat. Displays injects in a popup by default. Use the <code>return</code> argument to change the return type.',
+        helpString: t`Lists all script injections for the current chat. Displays injects in a popup by default. Use the <code>return</code> argument to change the return type.`,
-        returns: 'Optionalls the JSON object of script injections',
+        returns: t`Optionally the JSON object of script injections`,
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'return',
-                description: 'The way how you want the return value to be provided',
+                description: t`The way how you want the return value to be provided`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: 'popup-html',
                 enumList: slashCommandReturnHelper.enumList({ allowPipe: false, allowObject: true, allowChat: true, allowPopup: true, allowTextVersion: false }),

             // TODO remove some day
             SlashCommandNamedArgument.fromProps({
                 name: 'format',
-                description: '!!! DEPRECATED - use "return" instead !!! output format',
+                description: t`!!! DEPRECATED - use "return" instead !!! output format`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 forceEnum: true,
                 enumList: [
-                    new SlashCommandEnumValue('popup', 'Show injects in a popup.', enumTypes.enum, enumIcons.default),
+                    new SlashCommandEnumValue('popup', t`Show injects in a popup.`, enumTypes.enum, enumIcons.default),
-                    new SlashCommandEnumValue('chat', 'Post a system message to the chat.', enumTypes.enum, enumIcons.default),
+                    new SlashCommandEnumValue('chat', t`Post a system message to the chat.`, enumTypes.enum, enumIcons.default),
-                    new SlashCommandEnumValue('none', 'Just return the injects as a JSON object.', enumTypes.enum, enumIcons.default),
+                    new SlashCommandEnumValue('none', t`Just return the injects as a JSON object.`, enumTypes.enum, enumIcons.default),
                 ],
             }),
         ],

         aliases: ['flushinjects'],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'injection ID or a variable name pointing to ID',
+                description: t`injection ID or a variable name pointing to ID`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: '',
                 enumProvider: commonEnumProviders.injects,
             }),
         ],
         callback: flushInjectsCallback,
-        helpString: 'Removes a script injection for the current chat. If no ID is provided, removes all script injections.',
+        helpString: t`Removes a script injection for the current chat. If no ID is provided, removes all script injections.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'tokens',
         callback: (_, text) => {
-            if (text instanceof SlashCommandClosure || Array.isArray(text)) throw new Error('Unnamed argument cannot be a closure for command /tokens');
+            if (text instanceof SlashCommandClosure || Array.isArray(text)) throw new Error(t`Unnamed argument cannot be a closure for command /tokens`);
             return getTokenCountAsync(text).then(count => String(count));
         },
-        returns: 'number of tokens',
+        returns: t`number of tokens`,
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'text', [ARGUMENT_TYPE.STRING], true,
+                t`text`, [ARGUMENT_TYPE.STRING], true,
             ),
         ],
-        helpString: 'Counts the number of tokens in the provided text.',
+        helpString: t`Counts the number of tokens in the provided text.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'model',
         callback: modelCallback,
-        returns: 'current model',
+        returns: t`current model`,
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'quiet',
-                description: 'suppress the toast message on model change',
+                description: t`suppress the toast message on model change`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'false',
                 enumList: commonEnumProviders.boolean('trueFalse')(),

         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'model name',
+                description: t`model name`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 enumProvider: () => getModelOptions(true)?.options?.map(option => new SlashCommandEnumValue(option.value, option.value !== option.text ? option.text : null)) ?? [],
             }),
         ],
-        helpString: 'Sets the model for the current API. Gets the current model name if no argument is provided.',
+        helpString: t`Sets the model for the current API. Gets the current model name if no argument is provided.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'getpromptentry',
         aliases: ['getpromptentries'],
         callback: getPromptEntryCallback,
-        returns: 'true/false state of prompt(s)',
+        returns: t`true/false state of prompt(s)`,
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'identifier',
-                description: 'Prompt entry identifier(s) to retrieve',
+                description: t`Prompt entry identifier(s) to retrieve`,
                 typeList: [ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.LIST],
                 acceptsMultiple: true,
                 enumProvider: () =>

             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'name',
-                description: 'Prompt entry name(s) to retrieve',
+                description: t`Prompt entry name(s) to retrieve`,
                 typeList: [ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.LIST],
                 acceptsMultiple: true,
                 enumProvider: () =>

             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'return',
-                description: 'Whether the return will be simple, a list, or a dict.',
+                description: t`Whether the return will be simple, a list, or a dict.`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: 'simple',
                 enumList: ['simple', 'list', 'dict'],

         ],
         helpString: `
             <div>
-                Gets the state of the specified prompt entries.
+                ${t`Gets the state of the specified prompt entries.`}
             </div>
             <div>
-                If <code>return</code> is <code>simple</code> (default) then the return will be a single value if only one value was retrieved; otherwise uses a dict (if the identifier parameter was used) or a list.
+                ${t`If <code>return</code> is <code>simple</code> (default) then the return will be a single value if only one value was retrieved; otherwise uses a dict (if the identifier parameter was used) or a list.`}
             </div>
         `,
     }));

         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'identifier',
-                description: 'Prompt entry identifier(s) to target',
+                description: t`Prompt entry identifier(s) to target`,
                 typeList: [ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.LIST],
                 acceptsMultiple: true,
                 enumProvider: () => {

             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'name',
-                description: 'Prompt entry name(s) to target',
+                description: t`Prompt entry name(s) to target`,
                 typeList: [ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.LIST],
                 acceptsMultiple: true,
                 enumProvider: () => {

         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'Set entry/entries on or off',
+                description: t`Set entry/entries on or off`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 acceptsMultiple: false,

                 enumList: commonEnumProviders.boolean('onOffToggle')(),
             }),
         ],
-        helpString: 'Sets the specified prompt manager entry/entries on or off.',
+        helpString: t`Sets the specified prompt manager entry/entries on or off.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'pick-icon',
         callback: async () => ((await showFontAwesomePicker()) ?? false).toString(),
-        returns: 'The chosen icon name or false if cancelled.',
+        returns: t`The chosen icon name or false if cancelled.`,
         helpString: `
-                <div>Opens a popup with all the available Font Awesome icons and returns the selected icon's name.</div>
+                <div>${t`Opens a popup with all the available Font Awesome icons and returns the selected icon's name.`}</div>
                 <div>
-                    <strong>Example:</strong>
+                    <strong>${t`Example:`}</strong>
                     <ul>
                         <li>
                             <pre><code>/pick-icon |\n/if left={{pipe}} rule=eq right=false\n\telse={: /echo chosen icon: "{{pipe}}" :}\n\t{: /echo cancelled icon selection :}\n|</code></pre>

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'api-url',
         callback: setApiUrlCallback,
-        returns: 'the current API url',
+        returns: t`the current API url`,
         aliases: ['server'],
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'api',
-                description: 'API to set/get the URL for - if not provided, current API is used',
+                description: t`API to set/get the URL for - if not provided, current API is used`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 enumList: [
                     new SlashCommandEnumValue('custom', 'custom OpenAI-compatible', enumTypes.getBasedOnIndex(UNIQUE_APIS.findIndex(x => x === 'openai')), 'O'),

             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'connect',
-                description: 'Whether to auto-connect to the API after setting the URL',
+                description: t`Whether to auto-connect to the API after setting the URL`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'true',
                 enumList: commonEnumProviders.boolean('trueFalse')(),
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'quiet',
-                description: 'suppress the toast message on API change',
+                description: t`suppress the toast message on API change`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'false',
                 enumList: commonEnumProviders.boolean('trueFalse')(),

         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'API url to connect to',
+                description: t`API url to connect to`,
                 typeList: [ARGUMENT_TYPE.STRING],
             }),
         ],
         helpString: `
             <div>
-                Set the API url / server url for the currently selected API, including the port. If no argument is provided, it will return the current API url.
+                ${t`Set the API url / server url for the currently selected API, including the port. If no argument is provided, it will return the current API url.`}
             </div>
             <div>
-                If a manual API is provided to <b>set</b> the URL, make sure to set <code>connect=false</code>, as auto-connect only works for the currently selected API,
+                ${t`If a manual API is provided to <b>set</b> the URL, make sure to set <code>connect=false</code>, as auto-connect only works for the currently selected API, or consider switching to it with <code>/api</code> first.`}
-                or consider switching to it with <code>/api</code> first.
             </div>
             <div>
-                This slash command works for most of the Text Completion sources, KoboldAI Classic, and also Custom OpenAI compatible for the Chat Completion sources. If unsure which APIs are supported,
+                ${t`This slash command works for most of the Text Completion sources, KoboldAI Classic, and also Custom OpenAI compatible for the Chat Completion sources. If unsure which APIs are supported, check the auto-completion of the optional <code>api</code> argument of this command.`}
-                check the auto-completion of the optional <code>api</code> argument of this command.
             </div>
         `,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'tokenizer',
         callback: selectTokenizerCallback,
-        returns: 'current tokenizer',
+        returns: t`current tokenizer`,
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'tokenizer name',
+                description: t`tokenizer name`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 enumList: getAvailableTokenizers().map(tokenizer =>
                     new SlashCommandEnumValue(tokenizer.tokenizerKey, tokenizer.tokenizerName, enumTypes.enum, enumIcons.default)),

         ],
         helpString: `
             <div>
-                Selects tokenizer by name. Gets the current tokenizer if no name is provided.
+                ${t`Selects tokenizer by name. Gets the current tokenizer if no name is provided.`}
             </div>
             <div>
-                <strong>Available tokenizers:</strong>
+                <strong>${t`Available tokenizers:`}</strong>
                 <pre><code>${getAvailableTokenizers().map(t => t.tokenizerKey).join(', ')}</code></pre>
             </div>
         `,

         name: 'upper',
         aliases: ['uppercase', 'to-upper'],
         callback: (_, text) => typeof text === 'string' ? text.toUpperCase() : '',
-        returns: 'uppercase string',
+        returns: t`uppercase string`,
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'text to affect', [ARGUMENT_TYPE.STRING], true, false,
+                t`text to affect`, [ARGUMENT_TYPE.STRING], true, false,
             ),
         ],
-        helpString: 'Converts the provided string to uppercase.',
+        helpString: t`Converts the provided string to uppercase.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'lower',
         aliases: ['lowercase', 'to-lower'],
         callback: (_, text) => typeof text === 'string' ? text.toLowerCase() : '',
-        returns: 'lowercase string',
+        returns: t`lowercase string`,
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'text to affect', [ARGUMENT_TYPE.STRING], true, false,
+                t`text to affect`, [ARGUMENT_TYPE.STRING], true, false,
             ),
         ],
-        helpString: 'Converts the provided string to lowercase.',
+        helpString: t`Converts the provided string to lowercase.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'substr',
         aliases: ['substring'],
         callback: (arg, text) => typeof text === 'string' ? text.slice(...[Number(arg.start), arg.end && Number(arg.end)]) : '',
-        returns: 'substring',
+        returns: t`substring`,
         namedArgumentList: [
             new SlashCommandNamedArgument(
-                'start', 'start index', [ARGUMENT_TYPE.NUMBER], false, false,
+                'start', t`start index`, [ARGUMENT_TYPE.NUMBER], false, false,
             ),
             new SlashCommandNamedArgument(
-                'end', 'end index', [ARGUMENT_TYPE.NUMBER], false, false,
+                'end', t`end index`, [ARGUMENT_TYPE.NUMBER], false, false,
             ),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'text to affect', [ARGUMENT_TYPE.STRING], true, false,
+                t`text to affect`, [ARGUMENT_TYPE.STRING], true, false,
             ),
         ],
         helpString: `
             <div>
-                Extracts text from the provided string.
+                ${t`Extracts text from the provided string.`}
             </div>
             <div>
-                If <code>start</code> is omitted, it's treated as 0.<br />
+                ${t`If <code>start</code> is omitted, it's treated as 0.<br />`}
-                If <code>start</code> < 0, the index is counted from the end of the string.<br />
+                ${t`If <code>start</code> < 0, the index is counted from the end of the string.<br />`}
-                If <code>start</code> >= the string's length, an empty string is returned.<br />
+                ${t`If <code>start</code> >= the string's length, an empty string is returned.<br />`}
-                If <code>end</code> is omitted, or if <code>end</code> >= the string's length, extracts to the end of the string.<br />
+                ${t`If <code>end</code> is omitted, or if <code>end</code> >= the string's length, extracts to the end of the string.<br />`}
-                If <code>end</code> < 0, the index is counted from the end of the string.<br />
+                ${t`If <code>end</code> < 0, the index is counted from the end of the string.<br />`}
-                If <code>end</code> <= <code>start</code> after normalizing negative values, an empty string is returned.
+                ${t`If <code>end</code> <= <code>start</code> after normalizing negative values, an empty string is returned.`}
             </div>
             <div>
-                <strong>Example:</strong>
+                <strong>${t`Example:`}</strong>
                 <pre>/let x The morning is upon us.     ||                                     </pre>
                 <pre>/substr start=-3 {{var::x}}         | /echo  |/# us.                    ||</pre>
                 <pre>/substr start=-3 end=-1 {{var::x}}  | /echo  |/# us                     ||</pre>

         name: 'is-mobile',
         callback: () => String(isMobile()),
         returns: ARGUMENT_TYPE.BOOLEAN,
-        helpString: 'Returns true if the current device is a mobile device, false otherwise. Equivalent to <code>{{isMobile}}</code> macro.',
+        helpString: t`Returns true if the current device is a mobile device, false otherwise. Equivalent to <code>{{isMobile}}</code> macro.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'chat-render',
-        helpString: 'Renders a specified number of messages into the chat window. Displays all messages if no argument is provided.',
+        helpString: t`Renders a specified number of messages into the chat window. Displays all messages if no argument is provided.`,
         callback: async (args, number) => {
             await showMoreMessages(number && !isNaN(Number(number)) ? Number(number) : Number.MAX_SAFE_INTEGER);
             if (isTrueBoolean(String(args?.scroll ?? ''))) {

         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'scroll',
-                description: 'scroll to the top after rendering',
+                description: t`scroll to the top after rendering`,
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'false',
                 enumList: commonEnumProviders.boolean('trueFalse')(),

         ],
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'number of messages', [ARGUMENT_TYPE.NUMBER], false,
+                t`number of messages`, [ARGUMENT_TYPE.NUMBER], false,
             ),
         ],
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'chat-reload',
-        helpString: 'Reloads the current chat.',
+        helpString: t`Reloads the current chat.`,
         callback: async () => {
             await reloadCurrentChat();
             return '';

         aliases: ['re'],
         callback: (async ({ mode = 'literal', pattern, replacer = '' }, text) => {
             if (!pattern) {
-                throw new Error('Argument of \'pattern=\' cannot be empty');
+                throw new Error(t`Argument of 'pattern=' cannot be empty`);
+            }
             text = text.toString();
             pattern = pattern.toString();

                 case 'regex':
                     return text.replace(regexFromString(pattern), replacer);
                 default:
-                    throw new Error('Invalid \'/replace mode=\' argument specified!');
+                    throw new Error(t`Invalid '/replace mode=' argument specified!`);
+            }
         }),
-        returns: 'replaced text',
+        returns: t`replaced text`,
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'mode',
-                description: 'Replaces occurrence(s) of a pattern',
+                description: t`Replaces occurrence(s) of a pattern`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: 'literal',
                 enumList: ['literal', 'regex'],
             }),
             new SlashCommandNamedArgument(
-                'pattern', 'pattern to search with', [ARGUMENT_TYPE.STRING], true, false,
+                'pattern', t`pattern to search with`, [ARGUMENT_TYPE.STRING], true, false,
             ),
             new SlashCommandNamedArgument(
-                'replacer', 'replacement text for matches', [ARGUMENT_TYPE.STRING], false, false, '',
+                'replacer', t`replacement text for matches`, [ARGUMENT_TYPE.STRING], false, false, '',
             ),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'text to affect', [ARGUMENT_TYPE.STRING], true, false,
+                t`text to affect`, [ARGUMENT_TYPE.STRING], true, false,
             ),
         ],
         helpString: `
             <div>
-                Replaces text within the provided string based on the pattern.
+                ${t`Replaces text within the provided string based on the pattern.`}
             </div>
             <div>
-                If <code>mode</code> is <code>literal</code> (or omitted), <code>pattern</code> is a literal search string (case-sensitive).<br />
+                ${t`If <code>mode</code> is <code>literal</code> (or omitted), <code>pattern</code> is a literal search string (case-sensitive).<br />`}
-                If <code>mode</code> is <code>regex</code>, <code>pattern</code> is parsed as an ECMAScript Regular Expression.<br />
+                ${t`If <code>mode</code> is <code>regex</code>, <code>pattern</code> is parsed as an ECMAScript Regular Expression.<br />`}
-                The <code>replacer</code> replaces based on the <code>pattern</code> in the input text.<br />
+                ${t`The <code>replacer</code> replaces based on the <code>pattern</code> in the input text.<br />`}
-                If <code>replacer</code> is omitted, the replacement(s) will be an empty string.<br />
+                ${t`If <code>replacer</code> is omitted, the replacement(s) will be an empty string.<br />`}
             </div>
             <div>
-                <strong>Example:</strong>
+                <strong>${t`Example:`}</strong>
                 <pre><code class="language-stscript">/let x Blue house and blue car ||                                                                        </code></pre>
                 <pre><code class="language-stscript">/replace pattern="blue" {{var::x}}                                | /echo  |/# Blue house and  car     ||</code></pre>
                 <pre><code class="language-stscript">/replace pattern="blue" replacer="red" {{var::x}}                 | /echo  |/# Blue house and red car  ||</code></pre>

         name: 'test',
         callback: (({ pattern }, text) => {
             if (!pattern) {
-                throw new Error('Argument of \'pattern=\' cannot be empty');
+                throw new Error(t`Argument of 'pattern=' cannot be empty`);
+            }
             const re = regexFromString(pattern.toString());
             if (!re) {
-                throw new Error('The value of \'pattern\' argument is not a valid regular expression.');
+                throw new Error(t`The value of 'pattern' argument is not a valid regular expression.`);
+            }
             return JSON.stringify(re.test(text.toString()));
         }),
         returns: 'true | false',
         namedArgumentList: [
             new SlashCommandNamedArgument(
-                'pattern', 'pattern to find', [ARGUMENT_TYPE.STRING], true, false,
+                'pattern', t`pattern to find`, [ARGUMENT_TYPE.STRING], true, false,
             ),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'text to test', [ARGUMENT_TYPE.STRING], true, false,
+                t`text to test`, [ARGUMENT_TYPE.STRING], true, false,
             ),
         ],
         helpString: `
             <div>
-                Tests text for a regular expression match.
+                ${t`Tests text for a regular expression match.`}
             </div>
             <div>
-                Returns <code>true</code> if the match is found, <code>false</code> otherwise.
+                ${t`Returns <code>true</code> if the match is found, <code>false</code> otherwise.`}
             </div>
             <div>
-                <strong>Example:</strong>
+                <strong>${t`Example:`}</strong>
                 <pre><code class="language-stscript">/let x Blue house and green car                         ||</code></pre>
                 <pre><code class="language-stscript">/test pattern="green" {{var::x}}    | /echo  |/# true   ||</code></pre>
                 <pre><code class="language-stscript">/test pattern="blue" {{var::x}}     | /echo  |/# false  ||</code></pre>

         name: 'match',
         callback: (({ pattern }, text) => {
             if (!pattern) {
-                throw new Error('Argument of \'pattern=\' cannot be empty');
+                throw new Error(t`Argument of 'pattern=' cannot be empty`);
+            }
             const re = regexFromString(pattern.toString());
             if (!re) {
-                throw new Error('The value of \'pattern\' argument is not a valid regular expression.');
+                throw new Error(t`The value of 'pattern' argument is not a valid regular expression.`);
+            }
             if (re.flags.includes('g')) {
                 return JSON.stringify([...text.toString().matchAll(re)]);

                 return match ? JSON.stringify(match) : '';
+            }
         }),
-        returns: 'group array for each match',
+        returns: t`group array for each match`,
         namedArgumentList: [
             new SlashCommandNamedArgument(
-                'pattern', 'pattern to find', [ARGUMENT_TYPE.STRING], true, false,
+                'pattern', t`pattern to find`, [ARGUMENT_TYPE.STRING], true, false,
             ),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'text to match against', [ARGUMENT_TYPE.STRING], true, false,
+                t`text to match against`, [ARGUMENT_TYPE.STRING], true, false,
             ),
         ],
         helpString: `
             <div>
-                Retrieves regular expression matches in the given text
+                ${t`Retrieves regular expression matches in the given text`}
             </div>
             <div>
-                Returns an array of groups (with the first group being the full match). If the regex contains the global flag (i.e. <code>/g</code>),
+                ${t`Returns an array of groups (with the first group being the full match). If the regex contains the global flag (i.e. <code>/g</code>), multiple nested arrays are returned for each match. If the regex is global, returns <code>[]</code> if no matches are found, otherwise it returns an empty string.`}
-                multiple nested arrays are returned for each match. If the regex is global, returns <code>[]</code> if no matches are found,
-                otherwise it returns an empty string.
             </div>
             <div>
-                <strong>Example:</strong>
+                <strong>${t`Example:`}</strong>
                 <pre><code class="language-stscript">/let x color_green green lamp color_blue                                                                            ||</code></pre>
                 <pre><code class="language-stscript">/match pattern="green" {{var::x}}            | /echo  |/# [ "green" ]                                               ||</code></pre>
                 <pre><code class="language-stscript">/match pattern="color_(\\w+)" {{var::x}}      | /echo  |/# [ "color_green", "green" ]                                ||</code></pre>

         },
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'The message index (0-based) to scroll to.',
+                description: t`The message index (0-based) to scroll to.`,
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 isRequired: true,
                 enumProvider: commonEnumProviders.messages(),

         ],
         helpString: `
         <div>
-            Scrolls the chat view to the specified message index. Index starts at 0.
+            ${t`Scrolls the chat view to the specified message index. Index starts at 0.`}
         </div>
         <div>
-            <strong>Example:</strong> <pre><code>/chat-jump 10</code></pre> Scrolls to the 11th message (id=10).
+            <strong>${t`Example:`}</strong> <pre><code>/chat-jump 10</code></pre> ${t`Scrolls to the 11th message (id=10).`}
         </div>
     `,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'clipboard-get',
-        returns: 'clipboard text',
+        returns: t`clipboard text`,
         callback: async () => {
             if (!navigator.clipboard) {
-                toastr.warning('Clipboard API not available in this context.');
+                toastr.warning(t`Clipboard API not available in this context.`);
                 return '';
+            }

+            }
             catch (error) {
                 console.error('Error reading clipboard:', error);
-                toastr.warning('Failed to read clipboard text. Have you granted the permission?');
+                toastr.warning(t`Failed to read clipboard text. Have you granted the permission?`);
                 return '';
+            }
         },
-        helpString: 'Retrieves the text from the OS clipboard. Only works in secure contexts (HTTPS or localhost). Browser may ask for permission.',
+        helpString: t`Retrieves the text from the OS clipboard. Only works in secure contexts (HTTPS or localhost). Browser may ask for permission.`,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({

         },
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'text to copy to the clipboard',
+                description: t`text to copy to the clipboard`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 acceptsMultiple: false,
             }),
         ],
-        helpString: 'Copies the provided text to the OS clipboard. Returns an empty string.',
+        helpString: t`Copies the provided text to the OS clipboard. Returns an empty string.`,
     }));

         aliases: ['ppp'],
         helpString: `
             <div>
-                Sets a "Prompt Post-Processing" type. Gets the current selection if no value is provided.
+                ${t`Sets a "Prompt Post-Processing" type. Gets the current selection if no value is provided.`}
             </div>
             <div>
-                <strong>Examples:</strong>
+                <strong>${t`Examples:`}</strong>
             </div>
             <ul>
                 <li><pre><code class="language-stscript">/prompt-post-processing | /echo</code></pre></li>

         namedArgumentList: [],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'value',
+                description: t`value`,
                 typeList: [ARGUMENT_TYPE.STRING],
                 acceptsMultiple: false,
                 isRequired: true,

             const validValues = promptPostProcessingEnumProvider().map(option => option.value);
             if (!validValues.includes(stringValue)) {
-                throw new Error(`Invalid value "${stringValue}". Valid values are: ${validValues.join(', ')}`);
+                throw new Error(t`Invalid value "${stringValue}". Valid values are: ${validValues.join(', ')}`);
+            }
             // 'none' value must be coerced to an empty string

     const filter = args?.filter instanceof SlashCommandClosure ? args.filter.rawText : null;
     const filterFunction = args?.filter instanceof SlashCommandClosure ? closureToFilter(args.filter) : null;
     value = value || '';
     if (args?.filter && !String(filter ?? '').trim()) {
-        throw new Error('Failed to parse the filter argument. Make sure it is a valid non-empty closure.');
+        throw new Error(t`Failed to parse the filter argument. Make sure it is a valid non-empty closure.`);
+    }
     const prefixedId = `${SCRIPT_PROMPT_KEY}${id}`;

     // Old legacy return type handling
     if (args.format) {
-        toastr.warning(`Legacy argument 'format' with value '${args.format}' is deprecated. Please use 'return' instead. Routing to the correct return type...`, 'Deprecation warning');
+        toastr.warning(t`Legacy argument 'format' with value '${args.format}' is deprecated. Please use 'return' instead. Routing to the correct return type...`, t`Deprecation warning`);
         const type = String(args?.format).toLowerCase().trim();
         if (!chat_metadata.script_injects || !Object.keys(chat_metadata.script_injects).length) {
-            type !== 'none' && toastr.info('No script injections for the current chat');
+            type !== 'none' && toastr.info(t`No script injections for the current chat`);
+        }
         switch (type) {
             case 'none':

         const injectsStr = Object.entries(injects)
             .map(([id, inject]) => {
                 const position = Object.entries(extension_prompt_types);
-                const positionName = position.find(([_, value]) => value === inject.position)?.[0] ?? 'unknown';
+                const positionName = position.find(([_, value]) => value === inject.position)?.[0] ?? t`unknown`;
-                return `* **${id}**: <code>${inject.value}</code> (${positionName}, depth: ${inject.depth}, scan: ${inject.scan ?? false}, role: ${inject.role ?? extension_prompt_roles.SYSTEM})`;
+                return `* **${id}**: <code>${inject.value}</code> (${positionName}, ${t`depth`}: ${inject.depth}, ${t`scan`}: ${inject.scan ?? false}, ${t`role`}: ${inject.role ?? extension_prompt_roles.SYSTEM})`;
             })
             .join('\n');
-        return `### Script injections:\n${injectsStr || 'No script injections for the current chat'}`;
+        return `### ${t`Script injections:`}\n${injectsStr || t`No script injections for the current chat`}`;
     };
     return await slashCommandReturnHelper.doReturn(returnType ?? 'popup-html', chat_metadata.script_injects ?? {}, { objectToStringFunc: buildTextValue });

         wide: isTrueBoolean(args?.wide),
         wider: isTrueBoolean(args?.wider),
         transparent: isTrueBoolean(args?.transparent),
-        okButton: args?.okButton !== undefined && typeof args?.okButton === 'string' ? args.okButton : 'Ok',
+        okButton: args?.okButton !== undefined && typeof args?.okButton === 'string' ? args.okButton : t`OK`,
         cancelButton: args?.cancelButton !== undefined && typeof args?.cancelButton === 'string' ? args.cancelButton : null,
     };
     const result = await Popup.show.text(safeHeader, safeBody, popupOptions);

             return !isNarrator && mes.is_user;
+        }
-        throw new Error(`Invalid role provided. Expected one of: system, assistant, user. Got: ${role}`);
+        throw new Error(t`Invalid role provided. Expected one of: system, assistant, user. Got: ${role}`);
     };
     const processMessage = async (mesId) => {

 async function runCallback(args, name) {
     if (!name) {
-        throw new Error('No name provided for /run command');
+        throw new Error(t`No name provided for /run command`);
+    }
     if (name instanceof SlashCommandClosure) {

     if (scope.existsVariable(name)) {
         const closure = scope.getVariable(name);
         if (!(closure instanceof SlashCommandClosure)) {
-            throw new Error(`"${name}" is not callable.`);
+            throw new Error(t`"${name}" is not callable.`);
+        }
         closure.scope.parent = scope;
         closure.breakController = new SlashCommandBreakController();

@@ -3487,7 +3478,7 @@ async function runCallback(args, name) {
3487	}	3478	}
3488		3479
3489	if (typeof window['executeQuickReplyByName'] !== 'function') {	3480	if (typeof window['executeQuickReplyByName'] !== 'function') {
3490	throw new Error('Quick Reply extension is not loaded');	3481	throw new Error(t`Quick Reply extension is not loaded`);
3491	}	3482	}
3492		3483
3493	try {	3484	try {

@@ -3499,7 +3490,7 @@ async function runCallback(args, name) {
3499	};	3490	};
3500	return await window['executeQuickReplyByName'](name, args, options);	3491	return await window['executeQuickReplyByName'](name, args, options);
3501	} catch (error) {	3492	} catch (error) {
3502	throw new Error(`Error running Quick Reply "${name}": ${error.message}`);	3493	throw new Error(t`Error running Quick Reply "${name}": ${error.message}`);
3503	}	3494	}
3504	}	3495	}
3505		3496

  * @param {string} [reason]
  */
 function abortCallback({ _abortController, quiet }, reason) {
-    if (quiet instanceof SlashCommandClosure) throw new Error('argument \'quiet\' cannot be a closure for command /abort');
+    if (quiet instanceof SlashCommandClosure) throw new Error(t`argument 'quiet' cannot be a closure for command /abort`);
-    _abortController.abort((reason ?? '').toString().length == 0 ? '/abort command executed' : reason, !isFalseBoolean(quiet?.toString() ?? 'true'));
+    _abortController.abort((reason ?? '').toString().length == 0 ? t`/abort command executed` : reason, !isFalseBoolean(quiet?.toString() ?? 'true'));
     return '';
+}

     const popupOptions = {
         large: isTrueBoolean(args?.large),
         wide: isTrueBoolean(args?.wide),
-        okButton: args?.okButton !== undefined && typeof args?.okButton === 'string' ? args.okButton : 'Ok',
+        okButton: args?.okButton !== undefined && typeof args?.okButton === 'string' ? args.okButton : t`Ok`,
         rows: args?.rows !== undefined && typeof args?.rows === 'string' ? isNaN(Number(args.rows)) ? 4 : Number(args.rows) : 4,
     };
     // Do not remove this delay, otherwise the prompt will not show up

@@ -3549,7 +3540,7 @@ async function inputCallback(args, prompt) {
3549	// Veryify if a cancel handler exists and it is valid	3540	// Veryify if a cancel handler exists and it is valid
3550	if (args?.onCancel) {	3541	if (args?.onCancel) {
3551	if (!(args.onCancel instanceof SlashCommandClosure)) {	3542	if (!(args.onCancel instanceof SlashCommandClosure)) {
3552	throw new Error('argument \'onCancel\' must be a closure for command /input');	3543	throw new Error(t`argument 'onCancel' must be a closure for command /input`);
3553	}	3544	}
3554	await args.onCancel.execute();	3545	await args.onCancel.execute();
3555	}	3546	}

@@ -3557,7 +3548,7 @@ async function inputCallback(args, prompt) {
3557	// Verify if an ok handler exists and it is valid	3548	// Verify if an ok handler exists and it is valid
3558	if (args?.onSuccess) {	3549	if (args?.onSuccess) {
3559	if (!(args.onSuccess instanceof SlashCommandClosure)) {	3550	if (!(args.onSuccess instanceof SlashCommandClosure)) {
3560	throw new Error('argument \'onSuccess\' must be a closure for command /input');	3551	throw new Error(t`argument 'onSuccess' must be a closure for command /input`);
3561	}	3552	}
3562	await args.onSuccess.execute();	3553	await args.onSuccess.execute();
3563	}	3554	}

         return result;
     } catch (err) {
         console.error('Error on /genraw generation', err);
-        toastr.error(err.message, 'API Error', { preventDuplicates: true });
+        toastr.error(err.message, t`API Error`, { preventDuplicates: true });
     } finally {
         if (lock) {
             activateSendButtons();

         return result;
     } catch (err) {
         console.error('Error on /gen generation', err);
-        toastr.error(err.message, 'API Error', { preventDuplicates: true });
+        toastr.error(err.message, t`API Error`, { preventDuplicates: true });
     } finally {
         if (lock) {
             activateSendButtons();

@@ -3775,7 +3766,7 @@ async function echoCallback(args, value) {
3775	}	3766	}
3776		3767
3777	if (args.severity && !['error', 'warning', 'success', 'info'].includes(args.severity)) {	3768	if (args.severity && !['error', 'warning', 'success', 'info'].includes(args.severity)) {
3778	toastr.warning(`Invalid severity provided for /echo command: ${args.severity}`);	3769	toastr.warning(t`Invalid severity provided for /echo command: ${args.severity}`);
3779	args.severity = null;	3770	args.severity = null;
3780	}	3771	}
3781		3772

@@ -3808,7 +3799,7 @@ async function echoCallback(args, value) {
3808	await args.onClick.execute();	3799	await args.onClick.execute();
3809	};	3800	};
3810	} else {	3801	} else {
3811	toastr.warning('Invalid onClick provided for /echo command. This is not a closure');	3802	toastr.warning(t`Invalid onClick provided for /echo command. This is not a closure`);
3812	}	3803	}
3813	}	3804	}
3814		3805

     const lastMessage = chat[chat.length - 1];
     if (!lastMessage) {
-        toastr.warning('No messages to add swipes to.');
+        toastr.warning(t`No messages to add swipes to.`);
         return '';
+    }

@@ -3866,17 +3857,17 @@ async function addSwipeCallback(args, value) {
3866	}	3857	}
3867		3858
3868	if (lastMessage.is_user) {	3859	if (lastMessage.is_user) {
3869	toastr.warning('Can\'t add swipes to user messages.');	3860	toastr.warning(t`Can't add swipes to user messages.`);
3870	return '';	3861	return '';
3871	}	3862	}
3872		3863
3873	if (lastMessage.is_system) {	3864	if (lastMessage.is_system) {
3874	toastr.warning('Can\'t add swipes to system messages.');	3865	toastr.warning(t`Can't add swipes to system messages.`);
3875	return '';	3866	return '';
3876	}	3867	}
3877		3868
3878	if (lastMessage.extra?.image) {	3869	if (lastMessage.extra?.image) {
3879	toastr.warning('Can\'t add swipes to message containing an image.');	3870	toastr.warning(t`Can't add swipes to message containing an image.`);
3880	return '';	3871	return '';
3881	}	3872	}
3882		3873

     // Not supported in group chats
     // TODO: Maybe support group chats?
     if (selected_group) {
-        toastr.warning('Cannot run /ask command in a group chat!');
+        toastr.warning(t`Cannot run /ask command in a group chat!`);
         return '';
+    }
     if (!args.name) {
-        toastr.warning('You must specify a name of the character to ask.');
+        toastr.warning(t`You must specify a name of the character to ask.`);
         return '';
+    }

     // Find the character
     const character = findChar({ name: args?.name });
     if (!character) {
-        toastr.error('Character not found.');
+        toastr.error(t`Character not found.`);
         return '';
+    }

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

@@ -4004,7 +3995,7 @@ async function askCharacter(args, text) {
4004	if (String(this_chid) === String(prevChId)) {	3995	if (String(this_chid) === String(prevChId)) {
4005	await saveChatConditional();	3996	await saveChatConditional();
4006	} else {	3997	} else {
4007	toastr.error('It is strongly recommended to reload the page.', 'Something went wrong');	3998	toastr.error(t`It is strongly recommended to reload the page.`, t`Something went wrong`);
4008	}	3999	}
4009	}	4000	}
4010		4001

 async function disableGroupMemberCallback(_, arg) {
     if (!selected_group) {
-        toastr.warning('Cannot run /member-disable command outside of a group chat.');
+        toastr.warning(t`Cannot run /member-disable command outside of a group chat.`);
         return '';
+    }

 async function enableGroupMemberCallback(_, arg) {
     if (!selected_group) {
-        toastr.warning('Cannot run /member-enable command outside of a group chat.');
+        toastr.warning(t`Cannot run /member-enable command outside of a group chat.`);
         return '';
+    }

 async function moveGroupMemberUpCallback(_, arg) {
     if (!selected_group) {
-        toastr.warning('Cannot run /member-up command outside of a group chat.');
+        toastr.warning(t`Cannot run /member-up command outside of a group chat.`);
         return '';
+    }

 async function moveGroupMemberDownCallback(_, arg) {
     if (!selected_group) {
-        toastr.warning('Cannot run /member-down command outside of a group chat.');
+        toastr.warning(t`Cannot run /member-down command outside of a group chat.`);
         return '';
+    }

@@ -4141,12 +4132,12 @@ async function moveGroupMemberDownCallback(_, arg) {
4141		4132
4142	async function peekCallback(_, arg) {	4133	async function peekCallback(_, arg) {
4143	if (!selected_group) {	4134	if (!selected_group) {
4144	toastr.warning('Cannot run /member-peek command outside of a group chat.');	4135	toastr.warning(t`Cannot run /member-peek command outside of a group chat.`);
4145	return '';	4136	return '';
4146	}	4137	}
4147		4138
4148	if (is_group_generating) {	4139	if (is_group_generating) {
4149	toastr.warning('Cannot run /member-peek command while the group reply is generating.');	4140	toastr.warning(t`Cannot run /member-peek command while the group reply is generating.`);
4150	return '';	4141	return '';
4151	}	4142	}
4152		4143

 async function countGroupMemberCallback() {
     if (!selected_group) {
-        toastr.warning('Cannot run /member-count command outside of a group chat.');
+        toastr.warning(t`Cannot run /member-count command outside of a group chat.`);
         return '';
+    }

 async function removeGroupMemberCallback(_, arg) {
     if (!selected_group) {
-        toastr.warning('Cannot run /member-remove command outside of a group chat.');
+        toastr.warning(t`Cannot run /member-remove command outside of a group chat.`);
         return '';
+    }

 async function addGroupMemberCallback(_, name) {
     if (!selected_group) {
-        toastr.warning('Cannot run /memberadd command outside of a group chat.');
+        toastr.warning(t`Cannot run /memberadd command outside of a group chat.`);
         return '';
+    }

     const avatar = character.avatar;
     if (group.members.includes(avatar)) {
-        toastr.warning(`${character.name} is already a member of this group.`);
+        toastr.warning(t`${character.name} is already a member of this group.`);
         return '';
+    }

             await waitUntilCondition(() => !is_send_press && !is_group_generating, 10000, 100);
         } catch {
             console.warn('Timeout waiting for generation unlock');
-            toastr.warning('Cannot run /trigger command while the reply is being generated.');
+            toastr.warning(t`Cannot run /trigger command while the reply is being generated.`);
             outerResolve(Promise.resolve(''));
             return '';
+        }

     await saveChatConditional();
     await reloadCurrentChat();
-    toastr.info(`Deleted ${messagesToDelete.length} messages from ${name}`);
+    toastr.info(t`Deleted ${messagesToDelete.length} messages from ${name}`);
     return '';
+}

             await waitUntilCondition(() => !is_send_press && !is_group_generating, 10000, 100);
         } catch {
             console.warn('Timeout waiting for generation unlock');
-            toastr.warning('Cannot run /continue command while the reply is being generated.');
+            toastr.warning(t`Cannot run /continue command while the reply is being generated.`);
             return reject();
+        }

     if (!prompt) {
         console.warn('WARN: No prompt provided for /sysgen command');
-        toastr.warning('You must provide a prompt for the system message');
+        toastr.warning(t`You must provide a prompt for the system message`);
         return '';
+    }
     const trim = isTrueBoolean(args?.trim?.toString());
     // Generate and regex the output if applicable
-    const toast = toastr.info('Please wait', 'Generating...');
+    const toast = toastr.info(t`Please wait`, t`Generating...`);
     const message = await generateQuietPrompt({ quietPrompt: prompt, trimToSentence: trim });
     toastr.clear(toast);

 async function setNarratorName(_, text) {
     const name = text || NARRATOR_NAME_DEFAULT;
     chat_metadata[NARRATOR_NAME_KEY] = name;
-    toastr.info(`System narrator name set to ${name}`);
+    toastr.info(t`System narrator name set to ${name}`);
     await saveChatConditional();
     return '';
+}

@@ -4461,10 +4452,10 @@ async function setNarratorName(_, text) {
4461	export function validateArrayArgString(arg, name, { allowUndefined = true } = {}) {	4452	export function validateArrayArgString(arg, name, { allowUndefined = true } = {}) {
4462	if (arg === undefined) {	4453	if (arg === undefined) {
4463	if (allowUndefined) return undefined;	4454	if (allowUndefined) return undefined;
4464	throw new Error(`Argument "${name}" is undefined, but must be a string array`);	4455	throw new Error(t`Argument "${name}" is undefined, but must be a string array`);
4465	}	4456	}
4466	if (!Array.isArray(arg)) throw new Error(`Argument "${name}" must be an array`);	4457	if (!Array.isArray(arg)) throw new Error(t`Argument "${name}" must be an array`);
4467	if (!arg.every(x => typeof x === 'string')) throw new Error(`Argument "${name}" must be an array of strings`);	4458	if (!arg.every(x => typeof x === 'string')) throw new Error(t`Argument "${name}" must be an array of strings`);
4468	return arg;	4459	return arg;
4469	}	4460	}
4470		4461

@@ -4480,10 +4471,10 @@ export function validateArrayArgString(arg, name, { allowUndefined = true } = {}
4480	export function validateArrayArg(arg, name, { allowUndefined = true } = {}) {	4471	export function validateArrayArg(arg, name, { allowUndefined = true } = {}) {
4481	if (arg === undefined) {	4472	if (arg === undefined) {
4482	if (allowUndefined) return [];	4473	if (allowUndefined) return [];
4483	throw new Error(`Argument "${name}" is undefined, but must be an array of strings or closures`);	4474	throw new Error(t`Argument "${name}" is undefined, but must be an array of strings or closures`);
4484	}	4475	}
4485	if (!Array.isArray(arg)) throw new Error(`Argument "${name}" must be an array`);	4476	if (!Array.isArray(arg)) throw new Error(t`Argument "${name}" must be an array`);
4486	if (!arg.every(x => typeof x === 'string' \|\| x instanceof SlashCommandClosure)) throw new Error(`Argument "${name}" must be an array of strings or closures`);	4477	if (!arg.every(x => typeof x === 'string' \|\| x instanceof SlashCommandClosure)) throw new Error(t`Argument "${name}" must be an array of strings or closures`);
4487	return arg;	4478	return arg;
4488	}	4479	}
4489		4480

     if (!name) {
         const namelessWarningKey = 'sendAsNamelessWarningShown';
         if (accountStorage.getItem(namelessWarningKey) !== 'true') {
-            toastr.warning('To avoid confusion, please use /sendas name="Character Name"', 'Name defaulted to {{char}}', { timeOut: 10000 });
+            toastr.warning(t`To avoid confusion, please use /sendas name="Character Name"`, t`Name defaulted to {{char}}`, { timeOut: 10000 });
             accountStorage.setItem(namelessWarningKey, 'true');
+        }
         name = name2;

     const avatarCharacter = args.avatar ? findChar({ name: args.avatar }) : character;
     if (args.avatar && !avatarCharacter) {
-        toastr.warning(`Character for avatar ${args.avatar} not found`);
+        toastr.warning(t`Character for avatar ${args.avatar} not found`);
         return '';
+    }

     const result = fuse.search(bg);
     if (!result.length) {
-        toastr.error(`No background found with name "${bg}"`);
+        toastr.error(t`No background found with name "${bg}"`);
         return '';
+    }

     const modelSelectItem = modelSelectMap.find(x => x.api == main_api && x.type == apiSubType)?.id;
     if (!modelSelectItem) {
-        !quiet && toastr.info('Setting a model for your API is not supported or not implemented yet.');
+        !quiet && toastr.info(t`Setting a model for your API is not supported or not implemented yet.`);
         return nullResult;
+    }
     const modelSelectControl = document.getElementById(modelSelectItem);
     if (!(modelSelectControl instanceof HTMLSelectElement) && !(modelSelectControl instanceof HTMLInputElement)) {
-        !quiet && toastr.error(`Model select control not found: ${main_api}[${apiSubType}]`);
+        !quiet && toastr.error(t`Model select control not found: ${main_api}[${apiSubType}]`);
         return nullResult;
+    }

     if (modelSelectControl instanceof HTMLInputElement) {
         modelSelectControl.value = model;
         $(modelSelectControl).trigger('input');
-        !quiet && toastr.success(`Model set to "${model}"`);
+        !quiet && toastr.success(t`Model set to "${model}"`);
         return model;
+    }
     if (!options.length) {
-        !quiet && toastr.warning('No model options found. Check your API settings.');
+        !quiet && toastr.warning(t`No model options found. Check your API settings.`);
         return '';
+    }

     if (newSelectedOption) {
         modelSelectControl.value = newSelectedOption.value;
         $(modelSelectControl).trigger('change');
-        !quiet && toastr.success(`Model set to "${newSelectedOption.text}"`);
+        !quiet && toastr.success(t`Model set to "${newSelectedOption.text}"`);
         return newSelectedOption.value;
     } else {
-        !quiet && toastr.warning(`No model found with name "${model}"`);
+        !quiet && toastr.warning(t`No model found with name "${model}"`);
         return '';
+    }
+}

@@ -5149,7 +5140,7 @@ async function setApiUrlCallback({ api = null, connect = 'true', quiet = 'false'
5149	}	5140	}
5150		5141
5151	if (!isCurrentlyCustomOpenai && autoConnect) {	5142	if (!isCurrentlyCustomOpenai && autoConnect) {
5152	toastr.warning('Custom OpenAI API is not the currently selected API, so we cannot do an auto-connect. Consider switching to it via /api beforehand.');	5143	toastr.warning(t`Custom OpenAI API is not the currently selected API, so we cannot do an auto-connect. Consider switching to it via /api beforehand.`);
5153	return '';	5144	return '';
5154	}	5145	}
5155		5146

@@ -5170,7 +5161,7 @@ async function setApiUrlCallback({ api = null, connect = 'true', quiet = 'false'
5170	}	5161	}
5171		5162
5172	if (!isCurrentlyKoboldClassic && autoConnect) {	5163	if (!isCurrentlyKoboldClassic && autoConnect) {
5173	toastr.warning('Kobold Classic API is not the currently selected API, so we cannot do an auto-connect. Consider switching to it via /api beforehand.');	5164	toastr.warning(t`Kobold Classic API is not the currently selected API, so we cannot do an auto-connect. Consider switching to it via /api beforehand.`);
5174	return '';	5165	return '';
5175	}	5166	}
5176		5167

     const result = fuse.search(name);
     if (result.length === 0) {
-        toastr.warning(`Tokenizer "${name}" not found`);
+        toastr.warning(t`Tokenizer "${name}" not found`);
         return '';
+    }

         document.querySelector('#form_sheld').classList.add('script_error');
         result = new SlashCommandClosureResult();
         result.isError = true;
-        result.errorMessage = e.message || 'An unknown error occurred';
+        result.errorMessage = e.message || t`An unknown error occurred`;
         if (e.cause !== 'abort') {
             if (e instanceof SlashCommandExecutionError) {
                 /**@type {SlashCommandExecutionError}*/
                 const ex = e;
                 const toast = `
                     <div>${ex.message}</div>
-                    <div>Line: ${ex.line} Column: ${ex.column}</div>
+                    <div>${t`Line`}: ${ex.line} ${t`Column`}: ${ex.column}</div>
                     <pre style="text-align:left;">${ex.hint}</pre>
                     `;
-                const clickHint = '<p>Click to see details</p>';
+                const clickHint = `<p>${t`Click to see details`}</p>`;
                 toastr.error(
                     `${toast}${clickHint}`,
-                    'SlashCommandExecutionError',
+                    'Slash Command Execution Error',
                     { escapeHtml: false, timeOut: 10000, onclick: () => callGenericPopup(toast, POPUP_TYPE.TEXT, '', { allowHorizontalScrolling: true, allowVerticalScrolling: true }) },
                 );
             } else {

             const ex = e;
             const toast = `
                 <div>${ex.message}</div>
-                <div>Line: ${ex.line} Column: ${ex.column}</div>
+                <div>${t`Line`}: ${ex.line} ${t`Column`}: ${ex.column}</div>
                 <pre style="text-align:left;">${ex.hint}</pre>
                 `;
-            const clickHint = '<p>Click to see details</p>';
+            const clickHint = `<p>${t`Click to see details`}</p>`;
             toastr.error(
                 `${toast}${clickHint}`,
                 'SlashCommandParserError',

     try {
         const result = await closure.execute();
         if (result.isAborted && !result.isQuietlyAborted) {
-            toastr.warning(result.abortReason, 'Command execution aborted');
+            toastr.warning(result.abortReason, t`Command execution aborted`);
             closure.abortController.signal.isQuiet = true;
+        }
         return result;

public/scripts/slash-commands/SlashCommand.js+14 -15 Viewed

 import { SlashCommandScope } from './SlashCommandScope.js';
 /**
- * @typedef {{
+ * @typedef {NamedArgumentsCapture & {
  * _scope:SlashCommandScope,
  * _parserFlags:import('./SlashCommandParser.js').ParserFlags,
  * _abortController:SlashCommandAbortController,
  * _debugController:SlashCommandDebugController,
  * _hasUnnamedArgument:boolean,
- * [id:string]:string|SlashCommandClosure|(string|SlashCommandClosure)[]|undefined,
  * }} NamedArguments
  */

     /**@type {string}*/ name;
-    /**@type {(namedArguments:{_scope:SlashCommandScope, _abortController:SlashCommandAbortController, [id:string]:string|SlashCommandClosure}, unnamedArguments:string|SlashCommandClosure|(string|SlashCommandClosure)[])=>string|SlashCommandClosure|Promise<string|SlashCommandClosure>}*/ callback;
+    /**@type {(namedArguments:NamedArguments, unnamedArguments:UnnamedArguments)=>string|SlashCommandClosure|Promise<string|SlashCommandClosure>}*/ callback;
     /**@type {string}*/ helpString;
     /**@type {boolean}*/ splitUnnamedArgument = false;
     /**@type {Number}*/ splitUnnamedArgumentCount;

                     const name = document.createElement('div'); {
                         name.classList.add('name');
                         name.classList.add('monospace');
-                        name.title = 'command name';
+                        name.title = t`Command name`;
                         name.textContent = `/${key}`;
                         head.append(name);
+                    }

                                     const argItem = document.createElement('div'); {
                                         argItem.classList.add('argument');
                                         argItem.classList.add('namedArgument');
-                                        argItem.title = `${arg.isRequired ? '' : 'optional '}named argument`;
+                                        argItem.title = arg.isRequired ? t`Named argument` : t`Optional named argument`;
                                         if (!arg.isRequired || (arg.defaultValue ?? false)) argItem.classList.add('optional');
                                         if (arg.acceptsMultiple) argItem.classList.add('multiple');
                                         const name = document.createElement('span'); {
                                             name.classList.add('argument-name');
-                                            name.title = `${argItem.title} - name`;
+                                            name.title = t`${argItem.title} - Name`;
                                             name.textContent = arg.name;
                                             argItem.append(name);
+                                        }
                                         if (arg.enumList.length > 0) {
                                             const enums = document.createElement('span'); {
                                                 enums.classList.add('argument-enums');
-                                                enums.title = `${argItem.title} - accepted values`;
+                                                enums.title = t`${argItem.title} - Accepted values`;
                                                 for (const e of arg.enumList) {
                                                     const enumItem = document.createElement('span'); {
                                                         enumItem.classList.add('argument-enum');

                                         } else {
                                             const types = document.createElement('span'); {
                                                 types.classList.add('argument-types');
-                                                types.title = `${argItem.title} - accepted types`;
+                                                types.title = t`${argItem.title} - Accepted types`;
                                                 for (const t of arg.typeList) {
                                                     const type = document.createElement('span'); {
                                                         type.classList.add('argument-type');

                                     if (arg.defaultValue !== null) {
                                         const argDefault = document.createElement('div'); {
                                             argDefault.classList.add('argument-default');
-                                            argDefault.title = 'default value';
+                                            argDefault.title = t`Default value`;
                                             argDefault.textContent = arg.defaultValue.toString();
                                             argSpec.append(argDefault);
+                                        }

                                     const argItem = document.createElement('div'); {
                                         argItem.classList.add('argument');
                                         argItem.classList.add('unnamedArgument');
-                                        argItem.title = `${arg.isRequired ? '' : 'optional '}unnamed argument`;
+                                        argItem.title = arg.isRequired ? t`Unnamed argument` : t`Optional unnamed argument`;
                                         if (!arg.isRequired || (arg.defaultValue ?? false)) argItem.classList.add('optional');
                                         if (arg.acceptsMultiple) argItem.classList.add('multiple');
                                         if (arg.enumList.length > 0) {
                                             const enums = document.createElement('span'); {
                                                 enums.classList.add('argument-enums');
-                                                enums.title = `${argItem.title} - accepted values`;
+                                                enums.title = t`${argItem.title} - Accepted values`;
                                                 for (const e of arg.enumList) {
                                                     const enumItem = document.createElement('span'); {
                                                         enumItem.classList.add('argument-enum');

                                         } else {
                                             const types = document.createElement('span'); {
                                                 types.classList.add('argument-types');
-                                                types.title = `${argItem.title} - accepted types`;
+                                                types.title = t`${argItem.title} - Accepted types`;
                                                 for (const t of arg.typeList) {
                                                     const type = document.createElement('span'); {
                                                         type.classList.add('argument-type');

                                     if (arg.defaultValue !== null) {
                                         const argDefault = document.createElement('div'); {
                                             argDefault.classList.add('argument-default');
-                                            argDefault.title = 'default value';
+                                            argDefault.title = t`Default value`;
                                             argDefault.textContent = arg.defaultValue.toString();
                                             argSpec.append(argDefault);
+                                        }

@@ -402,7 +401,7 @@ export class SlashCommand {
402	}	401	}
403	const returns = document.createElement('span'); {	402	const returns = document.createElement('span'); {
404	returns.classList.add('returns');	403	returns.classList.add('returns');
405	returns.title = [null, undefined, 'void'].includes(returnType) ? 'command does not return anything' : 'return value';	404	returns.title = [null, undefined, 'void'].includes(returnType) ? t`Command does not return anything` : t`Return value`;
406	returns.textContent = returnType ?? 'void';	405	returns.textContent = returnType ?? 'void';
407	body.append(returns);	406	body.append(returns);
408	}	407	}

@@ -415,7 +414,7 @@ export class SlashCommand {
415	help.innerHTML = helpString;	414	help.innerHTML = helpString;
416	for (const code of help.querySelectorAll('pre > code')) {	415	for (const code of help.querySelectorAll('pre > code')) {
417	code.classList.add('language-stscript');	416	code.classList.add('language-stscript');
418	hljs.highlightElement(code);	417	hljs.highlightElement(/*@type {HTMLElement}/(code));
419	}	418	}
420	frag.append(help);	419	frag.append(help);
421	}	420	}

@@ -5187,26 +5178,26 @@ async function setApiUrlCallback({ api = null, connect = 'true', quiet = 'false'
5187		5178
5188	// Do some checks and get the api type we are targeting with this command	5179	// Do some checks and get the api type we are targeting with this command
5189	if (api && !Object.values(textgen_types).includes(api)) {	5180	if (api && !Object.values(textgen_types).includes(api)) {
5190	!isQuiet && toastr.warning(`API '${api}' is not a valid text_gen API.`);	5181	!isQuiet && toastr.warning(t`API '${api}' is not a valid text_gen API.`);
5191	return '';	5182	return '';
5192	}	5183	}
5193	if (!api && !Object.values(textgen_types).includes(textgenerationwebui_settings.type)) {	5184	if (!api && !Object.values(textgen_types).includes(textgenerationwebui_settings.type)) {
5194	!isQuiet && toastr.warning(`API '${textgenerationwebui_settings.type}' is not a valid text_gen API.`);	5185	!isQuiet && toastr.warning(t`API '${textgenerationwebui_settings.type}' is not a valid text_gen API.`);
5195	return '';	5186	return '';
5196	}	5187	}
5197	if (!api && main_api !== 'textgenerationwebui') {	5188	if (!api && main_api !== 'textgenerationwebui') {
5198	!isQuiet && toastr.warning(`API type '${main_api}' does not support setting the server URL.`);	5189	!isQuiet && toastr.warning(t`API type '${main_api}' does not support setting the server URL.`);
5199	return '';	5190	return '';
5200	}	5191	}
5201	if (api && url && autoConnect && api !== textgenerationwebui_settings.type) {	5192	if (api && url && autoConnect && api !== textgenerationwebui_settings.type) {
5202	!isQuiet && toastr.warning(`API '${api}' is not the currently selected API, so we cannot do an auto-connect. Consider switching to it via /api beforehand.`);	5193	!isQuiet && toastr.warning(t`API '${api}' is not the currently selected API, so we cannot do an auto-connect. Consider switching to it via /api beforehand.`);
5203	return '';	5194	return '';
5204	}	5195	}
5205	const type = api \|\| textgenerationwebui_settings.type;	5196	const type = api \|\| textgenerationwebui_settings.type;
5206		5197
5207	const inputSelector = SERVER_INPUTS[type];	5198	const inputSelector = SERVER_INPUTS[type];
5208	if (!inputSelector) {	5199	if (!inputSelector) {
5209	!isQuiet && toastr.warning(`API '${type}' does not have a server url input.`);	5200	!isQuiet && toastr.warning(t`API '${type}' does not have a server url input.`);
5210	return '';	5201	return '';
5211	}	5202	}
5212		5203