400 lines
23 KiB
Java
400 lines
23 KiB
Java
package com.discord.utilities.textprocessing;
|
|
|
|
import android.text.style.CharacterStyle;
|
|
import androidx.annotation.ColorInt;
|
|
import c.a.u.a.c;
|
|
import c.a.u.a.d;
|
|
import c.a.u.a.f;
|
|
import c.a.u.a.h;
|
|
import c.a.u.a.i;
|
|
import c.a.u.a.j;
|
|
import c.a.u.a.k;
|
|
import c.a.u.a.l;
|
|
import c.a.u.b.b.e;
|
|
import c.a.u.c.a;
|
|
import com.discord.models.domain.emoji.ModelEmojiUnicode;
|
|
import com.discord.simpleast.core.node.Node;
|
|
import com.discord.simpleast.core.node.StyleNode;
|
|
import com.discord.simpleast.core.parser.ParseSpec;
|
|
import com.discord.simpleast.core.parser.Parser;
|
|
import com.discord.simpleast.core.parser.Rule;
|
|
import com.discord.utilities.textprocessing.node.BasicRenderContext;
|
|
import com.discord.utilities.textprocessing.node.BlockQuoteNode;
|
|
import com.discord.utilities.textprocessing.node.ChannelMentionNode;
|
|
import com.discord.utilities.textprocessing.node.EmojiNode;
|
|
import com.discord.utilities.textprocessing.node.RoleMentionNode;
|
|
import com.discord.utilities.textprocessing.node.SpoilerNode;
|
|
import com.discord.utilities.textprocessing.node.UrlNode;
|
|
import com.discord.utilities.textprocessing.node.UserMentionNode;
|
|
import d0.g;
|
|
import d0.g0.s;
|
|
import d0.o;
|
|
import d0.t.h0;
|
|
import d0.t.n;
|
|
import d0.t.n0;
|
|
import d0.z.d.m;
|
|
import java.util.Arrays;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.regex.Matcher;
|
|
import java.util.regex.Pattern;
|
|
import kotlin.Lazy;
|
|
import kotlin.jvm.functions.Function0;
|
|
import kotlin.jvm.functions.Function1;
|
|
/* compiled from: Rules.kt */
|
|
public final class Rules {
|
|
private static final String HOOKED_LINK = "^\\$\\[((?:\\[[^]]*]|[^]]|](?=[^\\[]*]))*)?]\\(\\s*<?((?:[^\\s\\\\]|\\\\.)*?)>?(?:\\s+['\"]([\\s\\S]*?)['\"])?\\s*\\)";
|
|
public static final Rules INSTANCE = new Rules();
|
|
private static final String LINK = "^\\[((?:\\[[^]]*]|[^]]|](?=[^\\[]*]))*)]\\(\\s*<?((?:[^\\s\\\\]|\\\\.)*?)>?(?:\\s+['\"]([\\s\\S]*?)['\"])?\\s*\\)";
|
|
private static final Set<Character> PATHOLOGICAL_MASKED_LINK_ATTACK_SUSPICIOUS_CHARS = n0.setOf((Object[]) new Character[]{'[', ']'});
|
|
private static final Pattern PATTERN_BLOCK_QUOTE = Pattern.compile("^(?: *>>> +(.*)| *>(?!>>) +([^\\n]*\\n?))", 32);
|
|
private static final Pattern PATTERN_CHANNEL_MENTION = Pattern.compile("^<#(\\d+)>");
|
|
private static final Pattern PATTERN_CUSTOM_EMOJI = Pattern.compile("^<(a)?:([a-zA-Z_0-9]+):(\\d+)>");
|
|
private static final Pattern PATTERN_HOOKED_LINK = Pattern.compile("^\\$\\[((?:\\[[^]]*]|[^]]|](?=[^\\[]*]))*)?]\\(\\s*<?((?:[^\\s\\\\]|\\\\.)*?)>?(?:\\s+['\"]([\\s\\S]*?)['\"])?\\s*\\)");
|
|
private static final Pattern PATTERN_MASKED_LINK = Pattern.compile("^\\[((?:\\[[^]]*]|[^]]|](?=[^\\[]*]))*)]\\(\\s*<?((?:[^\\s\\\\]|\\\\.)*?)>?(?:\\s+['\"]([\\s\\S]*?)['\"])?\\s*\\)");
|
|
private static final Pattern PATTERN_MENTION = Pattern.compile("^<@!?(\\d+)>|^@(everyone|here)");
|
|
private static final Pattern PATTERN_NAMED_EMOJI = Pattern.compile("^:([^\\s:]+?(?:::skin-tone-\\d)?):");
|
|
private static final Pattern PATTERN_ROLE_MENTION = Pattern.compile("^<@&(\\d+)>");
|
|
private static final Pattern PATTERN_SOFT_HYPHEN = Pattern.compile("^\\u00AD");
|
|
private static final Pattern PATTERN_SPOILER = Pattern.compile("^\\|\\|([\\s\\S]+?)\\|\\|");
|
|
private static final Pattern PATTERN_UNESCAPE_EMOTICON = Pattern.compile("^(¯\\\\_\\(ツ\\)_/¯)");
|
|
private static final Lazy PATTERN_UNICODE_EMOJI$delegate = g.lazy(Rules$PATTERN_UNICODE_EMOJI$2.INSTANCE);
|
|
private static final Pattern PATTERN_URL = Pattern.compile("^(https?://[^\\s<]+[^<.,:;\"')\\]\\s])");
|
|
private static final Pattern PATTERN_URL_NO_EMBED = Pattern.compile("^<(https?://[^\\s<]+[^<.,:;\"')\\]\\s])>");
|
|
public static final String REGEX_CUSTOM_EMOJI = "<(a)?:([a-zA-Z_0-9]+):(\\d+)>";
|
|
private static final String REGEX_LINK_HREF_AND_TITLE = "\\s*<?((?:[^\\s\\\\]|\\\\.)*?)>?(?:\\s+['\"]([\\s\\S]*?)['\"])?\\s*";
|
|
private static final String REGEX_LINK_INSIDE = "(?:\\[[^]]*]|[^]]|](?=[^\\[]*]))*";
|
|
private static final String REGEX_URL = "(https?://[^\\s<]+[^<.,:;\"')\\]\\s])";
|
|
private static EmojiDataProvider emojiDataProvider;
|
|
|
|
/* compiled from: Rules.kt */
|
|
public interface BlockQuoteState<Self extends BlockQuoteState<Self>> {
|
|
boolean isInQuote();
|
|
|
|
Self newBlockQuoteState(boolean z2);
|
|
}
|
|
|
|
/* compiled from: Rules.kt */
|
|
public interface EmojiDataProvider {
|
|
Map<String, ModelEmojiUnicode> getUnicodeEmojiSurrogateMap();
|
|
|
|
Map<String, ModelEmojiUnicode> getUnicodeEmojisNamesMap();
|
|
|
|
Pattern getUnicodeEmojisPattern();
|
|
}
|
|
|
|
/* compiled from: Rules.kt */
|
|
public static final class HeaderLineClassedRule<RC, T, S> extends a.C0044a<RC, Object, S> {
|
|
private final Function0<List<Object>> headerPaddingSpanProvider;
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r2v0, resolved type: kotlin.jvm.functions.Function0<? extends java.util.List<? extends java.lang.Object>> */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
/* JADX INFO: super call moved to the top of the method (can break code semantics) */
|
|
public HeaderLineClassedRule(Function0<? extends List<? extends Object>> function0, Function1<? super Integer, ? extends CharacterStyle> function1, Function1<? super String, ? extends T> function12) {
|
|
super(function1, function12);
|
|
m.checkNotNullParameter(function0, "headerPaddingSpanProvider");
|
|
m.checkNotNullParameter(function1, "styleSpanProvider");
|
|
m.checkNotNullParameter(function12, "classSpanProvider");
|
|
this.headerPaddingSpanProvider = function0;
|
|
}
|
|
|
|
@Override // c.a.u.c.a.C0044a, c.a.u.c.a.b, c.a.u.c.a.c, com.discord.simpleast.core.parser.Rule
|
|
public ParseSpec<RC, S> parse(Matcher matcher, Parser<RC, ? super Node<RC>, S> parser, S s2) {
|
|
m.checkNotNullParameter(matcher, "matcher");
|
|
m.checkNotNullParameter(parser, "parser");
|
|
Node<RC> node = super.parse(matcher, parser, s2).a;
|
|
StyleNode styleNode = new StyleNode(this.headerPaddingSpanProvider.mo1invoke());
|
|
styleNode.addChild(node);
|
|
m.checkNotNullParameter(styleNode, "node");
|
|
return new ParseSpec<>(styleNode, s2);
|
|
}
|
|
}
|
|
|
|
/* compiled from: Rules.kt */
|
|
public static final class MarkdownListItemRule<RC, S> extends Rule.BlockRule<RC, Node<RC>, S> {
|
|
private final Function0<List<Object>> spansProvider;
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r2v0, resolved type: kotlin.jvm.functions.Function0<? extends java.util.List<? extends java.lang.Object>> */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
/* JADX INFO: super call moved to the top of the method (can break code semantics) */
|
|
public MarkdownListItemRule(Function0<? extends List<? extends Object>> function0) {
|
|
super(a.a);
|
|
m.checkNotNullParameter(function0, "spansProvider");
|
|
a aVar = a.e;
|
|
this.spansProvider = function0;
|
|
}
|
|
|
|
@Override // com.discord.simpleast.core.parser.Rule
|
|
public ParseSpec<RC, S> parse(Matcher matcher, Parser<RC, ? super Node<RC>, S> parser, S s2) {
|
|
m.checkNotNullParameter(matcher, "matcher");
|
|
m.checkNotNullParameter(parser, "parser");
|
|
StyleNode styleNode = new StyleNode(this.spansProvider.mo1invoke());
|
|
int start = matcher.start(1);
|
|
int end = matcher.end(1);
|
|
m.checkNotNullParameter(styleNode, "node");
|
|
return new ParseSpec<>(styleNode, s2, start, end);
|
|
}
|
|
}
|
|
|
|
private Rules() {
|
|
}
|
|
|
|
public static final /* synthetic */ EmojiDataProvider access$getEmojiDataProvider$p(Rules rules) {
|
|
EmojiDataProvider emojiDataProvider2 = emojiDataProvider;
|
|
if (emojiDataProvider2 == null) {
|
|
m.throwUninitializedPropertyAccessException("emojiDataProvider");
|
|
}
|
|
return emojiDataProvider2;
|
|
}
|
|
|
|
public static final /* synthetic */ Set access$getPATHOLOGICAL_MASKED_LINK_ATTACK_SUSPICIOUS_CHARS$p(Rules rules) {
|
|
return PATHOLOGICAL_MASKED_LINK_ATTACK_SUSPICIOUS_CHARS;
|
|
}
|
|
|
|
public static final /* synthetic */ String access$replaceEmojiSurrogates(Rules rules, String str) {
|
|
return rules.replaceEmojiSurrogates(str);
|
|
}
|
|
|
|
public static final /* synthetic */ void access$setEmojiDataProvider$p(Rules rules, EmojiDataProvider emojiDataProvider2) {
|
|
emojiDataProvider = emojiDataProvider2;
|
|
}
|
|
|
|
private final Pattern getPATTERN_UNICODE_EMOJI() {
|
|
return (Pattern) PATTERN_UNICODE_EMOJI$delegate.getValue();
|
|
}
|
|
|
|
private final String replaceEmojiSurrogates(String str) {
|
|
StringBuffer stringBuffer = new StringBuffer();
|
|
EmojiDataProvider emojiDataProvider2 = emojiDataProvider;
|
|
if (emojiDataProvider2 == null) {
|
|
m.throwUninitializedPropertyAccessException("emojiDataProvider");
|
|
}
|
|
Matcher matcher = emojiDataProvider2.getUnicodeEmojisPattern().matcher(str);
|
|
while (matcher.find()) {
|
|
String group = matcher.group();
|
|
EmojiDataProvider emojiDataProvider3 = emojiDataProvider;
|
|
if (emojiDataProvider3 == null) {
|
|
m.throwUninitializedPropertyAccessException("emojiDataProvider");
|
|
}
|
|
ModelEmojiUnicode modelEmojiUnicode = emojiDataProvider3.getUnicodeEmojiSurrogateMap().get(group);
|
|
if (modelEmojiUnicode != null) {
|
|
StringBuilder L = c.d.b.a.a.L(":");
|
|
L.append(modelEmojiUnicode.getFirstName());
|
|
L.append(":");
|
|
matcher.appendReplacement(stringBuffer, L.toString());
|
|
}
|
|
}
|
|
matcher.appendTail(stringBuffer);
|
|
String stringBuffer2 = stringBuffer.toString();
|
|
m.checkNotNullExpressionValue(stringBuffer2, "stringBuffer.toString()");
|
|
return stringBuffer2;
|
|
}
|
|
|
|
public static final void setEmojiDataProvider(EmojiDataProvider emojiDataProvider2) {
|
|
m.checkNotNullParameter(emojiDataProvider2, "emojiDataProvider");
|
|
emojiDataProvider = emojiDataProvider2;
|
|
}
|
|
|
|
private final long toLongOrDefault(String str, long j) {
|
|
Long longOrNull;
|
|
return (str == null || (longOrNull = s.toLongOrNull(str)) == null) ? j : longOrNull.longValue();
|
|
}
|
|
|
|
public static /* synthetic */ long toLongOrDefault$default(Rules rules, String str, long j, int i, Object obj) {
|
|
if ((i & 1) != 0) {
|
|
j = -1;
|
|
}
|
|
return rules.toLongOrDefault(str, j);
|
|
}
|
|
|
|
public final <T extends BasicRenderContext, S extends BlockQuoteState<S>> Rule.BlockRule<T, BlockQuoteNode<T>, S> createBlockQuoteRule() {
|
|
Pattern pattern = PATTERN_BLOCK_QUOTE;
|
|
m.checkNotNullExpressionValue(pattern, "PATTERN_BLOCK_QUOTE");
|
|
return new Rules$createBlockQuoteRule$1(this, pattern);
|
|
}
|
|
|
|
public final <T, S> Rule<T, Node<T>, S> createBoldColoredRule(@ColorInt int i) {
|
|
e eVar = e.h;
|
|
Pattern pattern = e.a;
|
|
m.checkNotNullExpressionValue(pattern, "PATTERN_BOLD");
|
|
return e.b(pattern, new Rules$createBoldColoredRule$1(i));
|
|
}
|
|
|
|
public final <T extends ChannelMentionNode.RenderContext, S> Rule<T, ChannelMentionNode<T>, S> createChannelMentionRule() {
|
|
Pattern pattern = PATTERN_CHANNEL_MENTION;
|
|
m.checkNotNullExpressionValue(pattern, "PATTERN_CHANNEL_MENTION");
|
|
return new Rules$createChannelMentionRule$1(this, pattern);
|
|
}
|
|
|
|
public final <RC extends BasicRenderContext, S extends BlockQuoteState<S>> Rule<RC, Node<RC>, S> createCodeBlockRule() {
|
|
f fVar = new f(Rules$createCodeBlockRule$codeStyleProviders$1.INSTANCE, Rules$createCodeBlockRule$codeStyleProviders$2.INSTANCE, Rules$createCodeBlockRule$codeStyleProviders$3.INSTANCE, Rules$createCodeBlockRule$codeStyleProviders$4.INSTANCE, Rules$createCodeBlockRule$codeStyleProviders$5.INSTANCE, Rules$createCodeBlockRule$codeStyleProviders$6.INSTANCE, Rules$createCodeBlockRule$codeStyleProviders$7.INSTANCE, Rules$createCodeBlockRule$codeStyleProviders$8.INSTANCE);
|
|
c.a.u.a.e eVar = c.a.u.a.e.f;
|
|
m.checkNotNullParameter(fVar, "codeStyleProviders");
|
|
i iVar = i.f;
|
|
m.checkNotNullParameter(fVar, "codeStyleProviders");
|
|
Pattern pattern = i.f228c;
|
|
m.checkNotNullExpressionValue(pattern, "PATTERN_KOTLIN_COMMENTS");
|
|
StyleNode.a<R> aVar = fVar.b;
|
|
m.checkNotNullParameter(pattern, "$this$toMatchGroupRule");
|
|
Pattern pattern2 = i.e;
|
|
m.checkNotNullExpressionValue(pattern2, "PATTERN_KOTLIN_STRINGS");
|
|
StyleNode.a<R> aVar2 = fVar.f227c;
|
|
m.checkNotNullParameter(pattern2, "$this$toMatchGroupRule");
|
|
Pattern pattern3 = i.d;
|
|
m.checkNotNullExpressionValue(pattern3, "PATTERN_KOTLIN_ANNOTATION");
|
|
StyleNode.a<R> aVar3 = fVar.g;
|
|
m.checkNotNullParameter(pattern3, "$this$toMatchGroupRule");
|
|
i.a.C0042a aVar4 = i.a.b;
|
|
m.checkNotNullParameter(fVar, "codeStyleProviders");
|
|
Pattern pattern4 = i.a.a;
|
|
m.checkNotNullExpressionValue(pattern4, "PATTERN_KOTLIN_FIELD");
|
|
i.b.a aVar5 = i.b.b;
|
|
m.checkNotNullParameter(fVar, "codeStyleProviders");
|
|
Rule[] ruleArr = {new d(pattern, 0, aVar, pattern), new d(pattern2, 0, aVar2, pattern2), new d(pattern3, 0, aVar3, pattern3), new h(aVar4, fVar, pattern4), new j(aVar5, fVar, i.b.a)};
|
|
String[] strArr = i.b;
|
|
String[] strArr2 = i.a;
|
|
List a = eVar.a(fVar, n.listOf((Object[]) ruleArr), new String[]{"object", "class", "interface"}, strArr, (String[]) Arrays.copyOf(strArr2, strArr2.length));
|
|
Pattern b = eVar.b("//");
|
|
m.checkNotNullExpressionValue(b, "createSingleLineCommentPattern(\"//\")");
|
|
Pattern compile = Pattern.compile("^\"[\\s\\S]*?(?<!\\\\)\"(?=\\W|\\s|$)");
|
|
m.checkNotNullExpressionValue(compile, "Pattern.compile(\"\"\"^\"[\\s…*?(?<!\\\\)\"(?=\\W|\\s|$)\"\"\")");
|
|
List a2 = eVar.a(fVar, n.listOf((Object[]) new Rule[]{c.a.u.a.e.d(eVar, b, 0, fVar.b, 1), c.a.u.a.e.d(eVar, compile, 0, fVar.f227c, 1)}), new String[]{"message|enum|extend|service"}, new String[]{"true|false", "string|bool|double|float|bytes", "int32|uint32|sint32|int64|unit64|sint64", "map"}, "required|repeated|optional|option|oneof|default|reserved", "package|import", "rpc|returns");
|
|
Pattern b2 = eVar.b("#");
|
|
m.checkNotNullExpressionValue(b2, "createSingleLineCommentPattern(\"#\")");
|
|
Pattern compile2 = Pattern.compile("^\"[\\s\\S]*?(?<!\\\\)\"(?=\\W|\\s|$)");
|
|
m.checkNotNullExpressionValue(compile2, "Pattern.compile(\"\"\"^\"[\\s…*?(?<!\\\\)\"(?=\\W|\\s|$)\"\"\")");
|
|
Pattern compile3 = Pattern.compile("^'[\\s\\S]*?(?<!\\\\)'(?=\\W|\\s|$)");
|
|
m.checkNotNullExpressionValue(compile3, "Pattern.compile(\"\"\"^'[\\s…*?(?<!\\\\)'(?=\\W|\\s|$)\"\"\")");
|
|
Pattern compile4 = Pattern.compile("^@(\\w+)");
|
|
m.checkNotNullExpressionValue(compile4, "Pattern.compile(\"\"\"^@(\\w+)\"\"\")");
|
|
List a3 = eVar.a(fVar, n.listOf((Object[]) new Rule[]{c.a.u.a.e.d(eVar, b2, 0, fVar.b, 1), c.a.u.a.e.d(eVar, compile2, 0, fVar.f227c, 1), c.a.u.a.e.d(eVar, compile3, 0, fVar.f227c, 1), c.a.u.a.e.d(eVar, compile4, 0, fVar.g, 1)}), new String[]{"class", "def", "lambda"}, new String[]{"True|False|None"}, "from|import|global|nonlocal", "async|await|class|self|cls|def|lambda", "for|while|if|else|elif|break|continue|return", "try|except|finally|raise|pass|yeild", "in|as|is|del", "and|or|not|assert");
|
|
Pattern b3 = eVar.b("//");
|
|
m.checkNotNullExpressionValue(b3, "createSingleLineCommentPattern(\"//\")");
|
|
Pattern compile5 = Pattern.compile("^\"[\\s\\S]*?(?<!\\\\)\"(?=\\W|\\s|$)");
|
|
m.checkNotNullExpressionValue(compile5, "Pattern.compile(\"\"\"^\"[\\s…*?(?<!\\\\)\"(?=\\W|\\s|$)\"\"\")");
|
|
Pattern compile6 = Pattern.compile("^#!?\\[.*?\\]\\n");
|
|
m.checkNotNullExpressionValue(compile6, "Pattern.compile(\"\"\"^#!?\\[.*?\\]\\n\"\"\")");
|
|
List a4 = eVar.a(fVar, n.listOf((Object[]) new Rule[]{c.a.u.a.e.d(eVar, b3, 0, fVar.b, 1), c.a.u.a.e.d(eVar, compile5, 0, fVar.f227c, 1), c.a.u.a.e.d(eVar, compile6, 0, fVar.g, 1)}), new String[]{"struct", "trait", "mod"}, new String[]{"Self|Result|Ok|Err|Option|None|Some", "Copy|Clone|Eq|Hash|Send|Sync|Sized|Debug|Display", "Arc|Rc|Box|Pin|Future", "true|false|bool|usize|i64|u64|u32|i32|str|String"}, "let|mut|static|const|unsafe", "crate|mod|extern|pub|pub(super)|use", "struct|enum|trait|type|where|impl|dyn|async|await|move|self|fn", "for|while|loop|if|else|match|break|continue|return|try", "in|as|ref");
|
|
k kVar = k.f229c;
|
|
m.checkNotNullParameter(fVar, "codeStyleProviders");
|
|
Pattern pattern5 = c.a.u.a.e.f226c;
|
|
Pattern pattern6 = c.a.u.a.e.d;
|
|
List listOf = n.listOf((Object[]) new Rule[]{c.a.u.a.e.d(eVar, k.a, 0, fVar.b, 1), new l(kVar, fVar, k.b), c.a.u.a.e.d(eVar, pattern5, 0, null, 3), c.a.u.a.e.d(eVar, pattern6, 0, null, 3)});
|
|
Pattern b4 = eVar.b("#");
|
|
m.checkNotNullExpressionValue(b4, "createSingleLineCommentPattern(\"#\")");
|
|
Pattern compile7 = Pattern.compile("^\"[\\s\\S]*?(?<!\\\\)\"(?=\\W|\\s|$)");
|
|
m.checkNotNullExpressionValue(compile7, "Pattern.compile(\"\"\"^\"[\\s…*?(?<!\\\\)\"(?=\\W|\\s|$)\"\"\")");
|
|
String pattern7 = eVar.c("true|false|null").pattern();
|
|
m.checkNotNullExpressionValue(pattern7, "createWordPattern(\"true|false|null\").pattern()");
|
|
Pattern compile8 = Pattern.compile(pattern7, 2);
|
|
m.checkNotNullExpressionValue(compile8, "java.util.regex.Pattern.compile(this, flags)");
|
|
String pattern8 = eVar.c("select|from|join|where|and|as|distinct|count|avg", "order by|group by|desc|sum|min|max", "like|having|in|is|not").pattern();
|
|
m.checkNotNullExpressionValue(pattern8, "createWordPattern(\n …ing|in|is|not\").pattern()");
|
|
Pattern compile9 = Pattern.compile(pattern8, 2);
|
|
m.checkNotNullExpressionValue(compile9, "java.util.regex.Pattern.compile(this, flags)");
|
|
List listOf2 = n.listOf((Object[]) new Rule[]{c.a.u.a.e.d(eVar, b4, 0, fVar.b, 1), c.a.u.a.e.d(eVar, compile7, 0, fVar.f227c, 1), c.a.u.a.e.d(eVar, compile8, 0, fVar.g, 1), c.a.u.a.e.d(eVar, compile9, 0, fVar.d, 1), c.a.u.a.e.d(eVar, c.a.u.a.e.e, 0, fVar.f227c, 1), c.a.u.a.e.d(eVar, pattern5, 0, null, 3), c.a.u.a.e.d(eVar, pattern6, 0, null, 3)});
|
|
Map mapOf = h0.mapOf(o.to("kt", a), o.to("kotlin", a), o.to("protobuf", a2), o.to("proto", a2), o.to("pb", a2), o.to("py", a3), o.to("python", a3), o.to("rs", a4), o.to("rust", a4), o.to("cql", listOf2), o.to("sql", listOf2), o.to("xml", listOf), o.to("http", listOf));
|
|
StyleNode.a<R> aVar6 = fVar.a;
|
|
Rules$createCodeBlockRule$1 rules$createCodeBlockRule$1 = Rules$createCodeBlockRule$1.INSTANCE;
|
|
m.checkNotNullParameter(aVar6, "textStyleProvider");
|
|
m.checkNotNullParameter(mapOf, "languageMap");
|
|
m.checkNotNullParameter(rules$createCodeBlockRule$1, "wrapperNodeProvider");
|
|
return new c.a.u.a.a(eVar, mapOf, aVar6, rules$createCodeBlockRule$1, c.a.u.a.e.a);
|
|
}
|
|
|
|
public final <T extends EmojiNode.RenderContext, S> Rule<T, EmojiNode<T>, S> createCustomEmojiRule() {
|
|
Pattern pattern = PATTERN_CUSTOM_EMOJI;
|
|
m.checkNotNullExpressionValue(pattern, "PATTERN_CUSTOM_EMOJI");
|
|
return new Rules$createCustomEmojiRule$1(this, pattern);
|
|
}
|
|
|
|
public final <T, S> Rule<T, Node<T>, S> createHookedLinkRule() {
|
|
Pattern pattern = PATTERN_HOOKED_LINK;
|
|
m.checkNotNullExpressionValue(pattern, "PATTERN_HOOKED_LINK");
|
|
return new Rules$createHookedLinkRule$1(this, pattern);
|
|
}
|
|
|
|
public final <RC extends BasicRenderContext, S extends BlockQuoteState<S>> Rule<RC, Node<RC>, S> createInlineCodeRule() {
|
|
c.a.u.a.e eVar = c.a.u.a.e.f;
|
|
Rules$createInlineCodeRule$1 rules$createInlineCodeRule$1 = Rules$createInlineCodeRule$1.INSTANCE;
|
|
Rules$createInlineCodeRule$2 rules$createInlineCodeRule$2 = Rules$createInlineCodeRule$2.INSTANCE;
|
|
m.checkNotNullParameter(rules$createInlineCodeRule$1, "textStyleProvider");
|
|
m.checkNotNullParameter(rules$createInlineCodeRule$2, "bgStyleProvider");
|
|
return new c(eVar, rules$createInlineCodeRule$1, rules$createInlineCodeRule$2, c.a.u.a.e.b);
|
|
}
|
|
|
|
public final <T extends UrlNode.RenderContext, S> Rule<T, UrlNode<T>, S> createMaskedLinkRule() {
|
|
Pattern pattern = PATTERN_MASKED_LINK;
|
|
m.checkNotNullExpressionValue(pattern, "PATTERN_MASKED_LINK");
|
|
return new Rules$createMaskedLinkRule$1(this, pattern);
|
|
}
|
|
|
|
public final <T extends EmojiNode.RenderContext, S> Rule<T, Node<T>, S> createNamedEmojiRule() {
|
|
Pattern pattern = PATTERN_NAMED_EMOJI;
|
|
m.checkNotNullExpressionValue(pattern, "PATTERN_NAMED_EMOJI");
|
|
return new Rules$createNamedEmojiRule$1(this, pattern);
|
|
}
|
|
|
|
public final <T extends RoleMentionNode.RenderContext, S> Rule<T, RoleMentionNode<T>, S> createRoleMentionRule() {
|
|
Pattern pattern = PATTERN_ROLE_MENTION;
|
|
m.checkNotNullExpressionValue(pattern, "PATTERN_ROLE_MENTION");
|
|
return new Rules$createRoleMentionRule$1(this, pattern);
|
|
}
|
|
|
|
public final <T, S> Rule<T, c.a.u.b.a.a<T>, S> createSoftHyphenRule() {
|
|
Pattern pattern = PATTERN_SOFT_HYPHEN;
|
|
m.checkNotNullExpressionValue(pattern, "PATTERN_SOFT_HYPHEN");
|
|
return new Rules$createSoftHyphenRule$1(this, pattern);
|
|
}
|
|
|
|
public final <T extends SpoilerNode.RenderContext, S> Rule<T, SpoilerNode<T>, S> createSpoilerRule() {
|
|
Pattern pattern = PATTERN_SPOILER;
|
|
m.checkNotNullExpressionValue(pattern, "PATTERN_SPOILER");
|
|
return new Rules$createSpoilerRule$1(this, pattern);
|
|
}
|
|
|
|
public final <T, S> Rule<T, Node<T>, S> createStrikethroughColoredRule(@ColorInt int i) {
|
|
e eVar = e.h;
|
|
Pattern pattern = e.f231c;
|
|
m.checkNotNullExpressionValue(pattern, "PATTERN_STRIKETHRU");
|
|
return e.b(pattern, new Rules$createStrikethroughColoredRule$1(i));
|
|
}
|
|
|
|
public final <T extends EmojiNode.RenderContext, S> Rule<T, Node<T>, S> createTextReplacementRule() {
|
|
e eVar = e.h;
|
|
Pattern pattern = e.e;
|
|
m.checkNotNullExpressionValue(pattern, "SimpleMarkdownRules.PATTERN_TEXT");
|
|
return new Rules$createTextReplacementRule$1(this, pattern);
|
|
}
|
|
|
|
public final <T, S> Rule<T, c.a.u.b.a.a<T>, S> createUnescapeEmoticonRule() {
|
|
Pattern pattern = PATTERN_UNESCAPE_EMOTICON;
|
|
m.checkNotNullExpressionValue(pattern, "PATTERN_UNESCAPE_EMOTICON");
|
|
return new Rules$createUnescapeEmoticonRule$1(this, pattern);
|
|
}
|
|
|
|
public final <T extends EmojiNode.RenderContext, S> Rule<T, Node<T>, S> createUnicodeEmojiRule() {
|
|
Pattern pattern_unicode_emoji = getPATTERN_UNICODE_EMOJI();
|
|
m.checkNotNullExpressionValue(pattern_unicode_emoji, "PATTERN_UNICODE_EMOJI");
|
|
return new Rules$createUnicodeEmojiRule$1(this, pattern_unicode_emoji);
|
|
}
|
|
|
|
public final <T extends UrlNode.RenderContext, S> Rule<T, UrlNode<T>, S> createUrlNoEmbedRule() {
|
|
Pattern pattern = PATTERN_URL_NO_EMBED;
|
|
m.checkNotNullExpressionValue(pattern, "PATTERN_URL_NO_EMBED");
|
|
return new Rules$createUrlNoEmbedRule$1(this, pattern);
|
|
}
|
|
|
|
public final <T extends UrlNode.RenderContext, S> Rule<T, UrlNode<T>, S> createUrlRule() {
|
|
Pattern pattern = PATTERN_URL;
|
|
m.checkNotNullExpressionValue(pattern, "PATTERN_URL");
|
|
return new Rules$createUrlRule$1(this, pattern);
|
|
}
|
|
|
|
public final <T extends UserMentionNode.RenderContext, S> Rule<T, Node<T>, S> createUserMentionRule() {
|
|
Pattern pattern = PATTERN_MENTION;
|
|
m.checkNotNullExpressionValue(pattern, "PATTERN_MENTION");
|
|
return new Rules$createUserMentionRule$1(this, pattern);
|
|
}
|
|
}
|