/// <summary>
/// Escape the mentions to their given names.
/// </summary>
/// <param name="client"></param>
/// <param name="value"></param>
/// <param name="type"></param>
/// <param name="guildId"></param>
/// <returns></returns>
public static ValueTask <string> EscapeMentionsAsync(this IDiscordClient client, string value, EscapeType type = EscapeType.Default, ulong?guildId = null)
{
if (type == EscapeType.Nothing)
{
return(default);
public static string ResolveEscapeChararter(EscapeType EscapeType)
{
switch (EscapeType)
{
case EscapeType.Field:
return(Escapes.Field);
case EscapeType.Component:
return(Escapes.Component);
case EscapeType.SubComponent:
return(Escapes.SubComponent);
case EscapeType.Repeat:
return(Escapes.Repeat);
case EscapeType.Escape:
return(Escapes.Escape);
case EscapeType.HighlightOn:
return(Escapes.HighlightStart);
case EscapeType.HighlightOff:
return(Escapes.HighlightEnd);
case EscapeType.LocallyDefined:
return(Escapes.Hexadecimal);
case EscapeType.HexadecimalData:
return(Escapes.LocallyDefined);
case EscapeType.NewLine:
return(Escapes.NewLine);
case EscapeType.SkipVerticalSpaces:
return(Escapes.SkipVerticalSpaces);
case EscapeType.WordWrapOn:
return(Escapes.WordWrapOn);
case EscapeType.WordWrapOff:
return(Escapes.WordWrapOff);
case EscapeType.Indent:
return(Escapes.Indent);
case EscapeType.TempIndent:
return(Escapes.TempIndent);
case EscapeType.SkipSpacesToRight:
return(Escapes.SkipSpacesToRight);
case EscapeType.CenterNextLine:
return(Escapes.CenterNextLine);
case EscapeType.NotAnEscape:
return(Escapes.NotAnEscape);
case EscapeType.Unknown:
return(Escapes.Unknown);
default:
return(Escapes.Unknown);
}
}
private static string UrlEncode(string str, Encoding e, EscapeType type)
{
if (str == null)
return string.Empty;
byte[] byt = e.GetBytes(str);
StringBuilder result = new StringBuilder(256);
for (int c = 0; c < byt.Length; c++)
{
byte chr = byt[c];
if ((ASCII_CLASS[chr] & (uint)UnSafe.UrlEscape) != 0)
{
switch (chr)
{
case (byte)'+':
if (type == EscapeType.EscapeAll)
{
result.Append("%20");
}
else if (type == EscapeType.EscapeExceptPlus)
{
result.Append("%2B");
}
break;
default:
result.Append("%" + ((int)chr).ToString("X2", CultureInfo.InvariantCulture));
break;
}
}
else
{
result.Append((char)chr);
}
}
return result.ToString();
}
private static string UrlDecode(string str, Encoding e, EscapeType type)
{
if (type == EscapeType.EscapeExceptPlus)
{
return HttpUtility.UrlDecode(str.Replace("%2b", "+").Replace("%2B", "+"), e);
}
return HttpUtility.UrlDecode(str.Replace("%20", "+"), e);
}
public static ValueTask <string> ReadRemainingAsync(this MessageRequest request, string name = null, bool required = false, EscapeType type = EscapeType.Default)
{
return(GetArgumentReader(request).ReadRemainingAsync(name, required, type));
}
public string ParseArguments(string input)
{
int index = 0;
List <Replacement> replacements = new List <Replacement>();
do
{
int tokenStart = input.IndexOf("%", index, StringComparison.InvariantCulture);
if (tokenStart == -1)
{
break;
}
int tokenEnd = input.IndexOf("%", tokenStart + 1, StringComparison.InvariantCulture);
if (tokenEnd == -1)
{
break;
}
int tokenLength = tokenEnd - tokenStart + 1;
int variableNameStart = tokenStart + 1;
int variableNameLength = tokenLength - 2;
bool isEnvironmentVariable = false;
string variableName = "";
if (tokenStart > 0)
{
char tokenStartPrefix = input.Substring(tokenStart - 1, 1).ToCharArray()[0];
char tokenEndPrefix = input.Substring(tokenEnd - 1, 1).ToCharArray()[0];
if (tokenStartPrefix == '\\' && tokenEndPrefix == '\\')
{
isEnvironmentVariable = true;
// Add the first backslash to the token
tokenStart--;
tokenLength++;
// Remove the last backslash from the name
variableNameLength--;
}
else if (tokenStartPrefix == '^' && tokenEndPrefix == '^')
{
// Add the first caret to the token
tokenStart--;
tokenLength++;
// Remove the last caret from the name
variableNameLength--;
variableName = input.Substring(variableNameStart, variableNameLength);
replacements.Add(new Replacement(tokenStart, tokenLength, $"%{variableName}%"));
index = tokenEnd;
continue;
}
}
string token = input.Substring(tokenStart, tokenLength);
EscapeType escape = EscapeType.All;
string prefix = input.Substring(variableNameStart, 1);
switch (prefix)
{
case "-":
escape = EscapeType.ShellMetacharacters;
break;
case "!":
escape = EscapeType.None;
break;
}
if (escape != EscapeType.All)
{
// Remove the escape character from the name
variableNameStart++;
variableNameLength--;
}
if (variableNameLength == 0)
{
index = tokenEnd;
continue;
}
variableName = input.Substring(variableNameStart, variableNameLength);
string replacementValue = token;
if (!isEnvironmentVariable)
{
replacementValue = GetVariableReplacement(variableName, token);
}
bool haveReplacement = false;
if (replacementValue != token)
{
haveReplacement = true;
}
else
{
replacementValue = Environment.GetEnvironmentVariable(variableName);
if (replacementValue != null)
{
haveReplacement = true;
}
}
if (haveReplacement)
{
var trailing = tokenEnd + 2 <= input.Length ? input.Substring(tokenEnd + 1, 1).ToCharArray()[0] : '\0';
if (escape == EscapeType.All)
{
replacementValue = CommandLineArguments.EscapeBackslashes(replacementValue);
if (trailing == '\'')
{
replacementValue = CommandLineArguments.EscapeBackslashesForTrailingQuote(replacementValue);
}
}
if (escape == EscapeType.All || escape == EscapeType.ShellMetacharacters)
{
replacementValue = CommandLineArguments.EscapeShellMetacharacters(replacementValue);
}
replacements.Add(new Replacement(tokenStart, tokenLength, replacementValue));
index = tokenEnd + 1;
}
else
{
index = tokenEnd;
}
} while (true);
string result = input;
for (index = result.Length; index >= 0; index--)
{
foreach (Replacement replacement in replacements)
{
if (replacement.Start != index)
{
continue;
}
string before = result.Substring(0, replacement.Start);
string after = result.Substring(replacement.Start + replacement.Length);
result = before + replacement.Value + after;
}
}
return(result);
}
public EscapeAttribute(EscapeType type)
{
Type = type;
}
