package com.discord.utilities.textprocessing;

import android.text.style.CharacterStyle;
import androidx.annotation.ColorInt;
import c.a.t.a.c;
import c.a.t.a.f;
import c.a.t.a.h;
import c.a.t.a.i;
import c.a.t.a.j;
import c.a.t.a.k;
import c.a.t.a.l;
import c.a.t.a.m;
import c.a.t.a.n;
import c.a.t.a.o;
import c.a.t.a.p;
import c.a.t.b.b.e;
import c.a.t.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.TimestampNode;
import com.discord.utilities.textprocessing.node.UrlNode;
import com.discord.utilities.textprocessing.node.UserMentionNode;
import d0.g;
import d0.g0.s;
import d0.t.h0;
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(HOOKED_LINK);
    private static final Pattern PATTERN_MASKED_LINK = Pattern.compile(LINK);
    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_TIMESTAMP = Pattern.compile("^<t:(-?\\d{1,17})(?::(t|T|d|D|f|F|R))?>");
    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.C0047a<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.t.c.a.C0047a, c.a.t.c.a.b, c.a.t.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.c(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.t.a.e eVar = c.a.t.a.e.f;
        m.checkNotNullParameter(fVar, "codeStyleProviders");
        c.a.t.a.m mVar = c.a.t.a.m.f;
        m.checkNotNullParameter(fVar, "codeStyleProviders");
        Pattern pattern = c.a.t.a.m.f236c;
        m.checkNotNullExpressionValue(pattern, "PATTERN_KOTLIN_COMMENTS");
        Pattern pattern2 = c.a.t.a.m.e;
        m.checkNotNullExpressionValue(pattern2, "PATTERN_KOTLIN_STRINGS");
        Pattern pattern3 = c.a.t.a.m.d;
        m.checkNotNullExpressionValue(pattern3, "PATTERN_KOTLIN_ANNOTATION");
        m.a.C0045a aVar = m.a.b;
        d0.z.d.m.checkNotNullParameter(fVar, "codeStyleProviders");
        Pattern pattern4 = m.a.a;
        d0.z.d.m.checkNotNullExpressionValue(pattern4, "PATTERN_KOTLIN_FIELD");
        m.b.a aVar2 = m.b.b;
        d0.z.d.m.checkNotNullParameter(fVar, "codeStyleProviders");
        Rule[] ruleArr = {c.a.t.a.e.d(eVar, pattern, 0, fVar.b, 1), c.a.t.a.e.d(eVar, pattern2, 0, fVar.f234c, 1), c.a.t.a.e.d(eVar, pattern3, 0, fVar.g, 1), new l(aVar, fVar, pattern4), new n(aVar2, fVar, m.b.a)};
        String[] strArr = c.a.t.a.m.b;
        String[] strArr2 = c.a.t.a.m.a;
        List a = eVar.a(fVar, d0.t.n.listOf((Object[]) ruleArr), new String[]{"object", "class", "interface"}, strArr, (String[]) Arrays.copyOf(strArr2, strArr2.length));
        Pattern b = eVar.b("//");
        d0.z.d.m.checkNotNullExpressionValue(b, "createSingleLineCommentPattern(\"//\")");
        Pattern compile = Pattern.compile("^\"[\\s\\S]*?(?<!\\\\)\"(?=\\W|\\s|$)");
        d0.z.d.m.checkNotNullExpressionValue(compile, "Pattern.compile(\"\"\"^\"[\\s…*?(?<!\\\\)\"(?=\\W|\\s|$)\"\"\")");
        List a2 = eVar.a(fVar, d0.t.n.listOf((Object[]) new Rule[]{c.a.t.a.e.d(eVar, b, 0, fVar.b, 1), c.a.t.a.e.d(eVar, compile, 0, fVar.f234c, 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("#");
        d0.z.d.m.checkNotNullExpressionValue(b2, "createSingleLineCommentPattern(\"#\")");
        Pattern compile2 = Pattern.compile("^\"[\\s\\S]*?(?<!\\\\)\"(?=\\W|\\s|$)");
        d0.z.d.m.checkNotNullExpressionValue(compile2, "Pattern.compile(\"\"\"^\"[\\s…*?(?<!\\\\)\"(?=\\W|\\s|$)\"\"\")");
        Pattern compile3 = Pattern.compile("^'[\\s\\S]*?(?<!\\\\)'(?=\\W|\\s|$)");
        d0.z.d.m.checkNotNullExpressionValue(compile3, "Pattern.compile(\"\"\"^'[\\s…*?(?<!\\\\)'(?=\\W|\\s|$)\"\"\")");
        Pattern compile4 = Pattern.compile("^@(\\w+)");
        d0.z.d.m.checkNotNullExpressionValue(compile4, "Pattern.compile(\"\"\"^@(\\w+)\"\"\")");
        List a3 = eVar.a(fVar, d0.t.n.listOf((Object[]) new Rule[]{c.a.t.a.e.d(eVar, b2, 0, fVar.b, 1), c.a.t.a.e.d(eVar, compile2, 0, fVar.f234c, 1), c.a.t.a.e.d(eVar, compile3, 0, fVar.f234c, 1), c.a.t.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("//");
        d0.z.d.m.checkNotNullExpressionValue(b3, "createSingleLineCommentPattern(\"//\")");
        Pattern compile5 = Pattern.compile("^\"[\\s\\S]*?(?<!\\\\)\"(?=\\W|\\s|$)");
        d0.z.d.m.checkNotNullExpressionValue(compile5, "Pattern.compile(\"\"\"^\"[\\s…*?(?<!\\\\)\"(?=\\W|\\s|$)\"\"\")");
        Pattern compile6 = Pattern.compile("^#!?\\[.*?\\]\\n");
        d0.z.d.m.checkNotNullExpressionValue(compile6, "Pattern.compile(\"\"\"^#!?\\[.*?\\]\\n\"\"\")");
        List a4 = eVar.a(fVar, d0.t.n.listOf((Object[]) new Rule[]{c.a.t.a.e.d(eVar, b3, 0, fVar.b, 1), c.a.t.a.e.d(eVar, compile5, 0, fVar.f234c, 1), c.a.t.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");
        o oVar = o.f237c;
        d0.z.d.m.checkNotNullParameter(fVar, "codeStyleProviders");
        Pattern pattern5 = c.a.t.a.e.f233c;
        Pattern pattern6 = c.a.t.a.e.d;
        List listOf = d0.t.n.listOf((Object[]) new Rule[]{c.a.t.a.e.d(eVar, o.a, 0, fVar.b, 1), new p(oVar, fVar, o.b), c.a.t.a.e.d(eVar, pattern5, 0, null, 3), c.a.t.a.e.d(eVar, pattern6, 0, null, 3)});
        Pattern b4 = eVar.b("#");
        d0.z.d.m.checkNotNullExpressionValue(b4, "createSingleLineCommentPattern(\"#\")");
        Pattern compile7 = Pattern.compile("^\"[\\s\\S]*?(?<!\\\\)\"(?=\\W|\\s|$)");
        d0.z.d.m.checkNotNullExpressionValue(compile7, "Pattern.compile(\"\"\"^\"[\\s…*?(?<!\\\\)\"(?=\\W|\\s|$)\"\"\")");
        String pattern7 = eVar.c("true|false|null").pattern();
        d0.z.d.m.checkNotNullExpressionValue(pattern7, "createWordPattern(\"true|false|null\").pattern()");
        Pattern compile8 = Pattern.compile(pattern7, 2);
        d0.z.d.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();
        d0.z.d.m.checkNotNullExpressionValue(pattern8, "createWordPattern(\n     …ing|in|is|not\").pattern()");
        Pattern compile9 = Pattern.compile(pattern8, 2);
        d0.z.d.m.checkNotNullExpressionValue(compile9, "java.util.regex.Pattern.compile(this, flags)");
        List listOf2 = d0.t.n.listOf((Object[]) new Rule[]{c.a.t.a.e.d(eVar, b4, 0, fVar.b, 1), c.a.t.a.e.d(eVar, compile7, 0, fVar.f234c, 1), c.a.t.a.e.d(eVar, compile8, 0, fVar.g, 1), c.a.t.a.e.d(eVar, compile9, 0, fVar.d, 1), c.a.t.a.e.d(eVar, c.a.t.a.e.e, 0, fVar.f234c, 1), c.a.t.a.e.d(eVar, pattern5, 0, null, 3), c.a.t.a.e.d(eVar, pattern6, 0, null, 3)});
        i iVar = i.g;
        d0.z.d.m.checkNotNullParameter(fVar, "codeStyleProviders");
        Pattern pattern9 = i.e;
        d0.z.d.m.checkNotNullExpressionValue(pattern9, "PATTERN_JAVASCRIPT_COMMENTS");
        Pattern pattern10 = i.f;
        d0.z.d.m.checkNotNullExpressionValue(pattern10, "PATTERN_JAVASCRIPT_STRINGS");
        i.c.a aVar3 = i.c.b;
        d0.z.d.m.checkNotNullParameter(fVar, "codeStyleProviders");
        Pattern pattern11 = i.c.a;
        d0.z.d.m.checkNotNullExpressionValue(pattern11, "PATTERN_JAVASCRIPT_OBJECT_PROPERTY");
        Pattern pattern12 = i.d;
        d0.z.d.m.checkNotNullExpressionValue(pattern12, "PATTERN_JAVASCRIPT_GENERIC");
        Pattern pattern13 = i.f235c;
        d0.z.d.m.checkNotNullExpressionValue(pattern13, "PATTERN_JAVASCRIPT_REGEX");
        i.a.C0044a aVar4 = i.a.b;
        d0.z.d.m.checkNotNullParameter(fVar, "codeStyleProviders");
        Pattern pattern14 = i.a.a;
        d0.z.d.m.checkNotNullExpressionValue(pattern14, "PATTERN_JAVASCRIPT_FIELD");
        i.b.a aVar5 = i.b.b;
        d0.z.d.m.checkNotNullParameter(fVar, "codeStyleProviders");
        Rule[] ruleArr2 = {c.a.t.a.e.d(eVar, pattern9, 0, fVar.b, 1), c.a.t.a.e.d(eVar, pattern10, 0, fVar.f234c, 1), new k(aVar3, fVar, pattern11), c.a.t.a.e.d(eVar, pattern12, 0, fVar.g, 1), c.a.t.a.e.d(eVar, pattern13, 0, fVar.f234c, 1), new h(aVar4, fVar, pattern14), new j(aVar5, fVar, i.b.a)};
        String[] strArr3 = i.b;
        String[] strArr4 = i.a;
        List a5 = eVar.a(fVar, d0.t.n.listOf((Object[]) ruleArr2), new String[]{"class"}, strArr3, (String[]) Arrays.copyOf(strArr4, strArr4.length));
        Map mapOf = h0.mapOf(d0.o.to("kt", a), d0.o.to("kotlin", a), d0.o.to("protobuf", a2), d0.o.to("proto", a2), d0.o.to("pb", a2), d0.o.to("py", a3), d0.o.to("python", a3), d0.o.to("rs", a4), d0.o.to("rust", a4), d0.o.to("cql", listOf2), d0.o.to("sql", listOf2), d0.o.to("xml", listOf), d0.o.to("http", listOf), d0.o.to("js", a5), d0.o.to("javascript", a5));
        StyleNode.a<R> aVar6 = fVar.a;
        Rules$createCodeBlockRule$1 rules$createCodeBlockRule$1 = Rules$createCodeBlockRule$1.INSTANCE;
        d0.z.d.m.checkNotNullParameter(aVar6, "textStyleProvider");
        d0.z.d.m.checkNotNullParameter(mapOf, "languageMap");
        d0.z.d.m.checkNotNullParameter(rules$createCodeBlockRule$1, "wrapperNodeProvider");
        return new c.a.t.a.a(eVar, mapOf, aVar6, rules$createCodeBlockRule$1, c.a.t.a.e.a);
    }

    public final <T extends EmojiNode.RenderContext, S> Rule<T, EmojiNode<T>, S> createCustomEmojiRule() {
        Pattern pattern = PATTERN_CUSTOM_EMOJI;
        d0.z.d.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;
        d0.z.d.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.t.a.e eVar = c.a.t.a.e.f;
        Rules$createInlineCodeRule$1 rules$createInlineCodeRule$1 = Rules$createInlineCodeRule$1.INSTANCE;
        Rules$createInlineCodeRule$2 rules$createInlineCodeRule$2 = Rules$createInlineCodeRule$2.INSTANCE;
        d0.z.d.m.checkNotNullParameter(rules$createInlineCodeRule$1, "textStyleProvider");
        d0.z.d.m.checkNotNullParameter(rules$createInlineCodeRule$2, "bgStyleProvider");
        return new c(eVar, rules$createInlineCodeRule$1, rules$createInlineCodeRule$2, c.a.t.a.e.b);
    }

    public final <T extends UrlNode.RenderContext, S> Rule<T, UrlNode<T>, S> createMaskedLinkRule() {
        Pattern pattern = PATTERN_MASKED_LINK;
        d0.z.d.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;
        d0.z.d.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;
        d0.z.d.m.checkNotNullExpressionValue(pattern, "PATTERN_ROLE_MENTION");
        return new Rules$createRoleMentionRule$1(this, pattern);
    }

    public final <T, S> Rule<T, c.a.t.b.a.a<T>, S> createSoftHyphenRule() {
        Pattern pattern = PATTERN_SOFT_HYPHEN;
        d0.z.d.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;
        d0.z.d.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.f239c;
        d0.z.d.m.checkNotNullExpressionValue(pattern, "PATTERN_STRIKETHRU");
        return e.c(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;
        d0.z.d.m.checkNotNullExpressionValue(pattern, "SimpleMarkdownRules.PATTERN_TEXT");
        return new Rules$createTextReplacementRule$1(this, pattern);
    }

    public final <T extends TimestampNode.RenderContext, S> Rule<T, TimestampNode<T>, S> createTimestampRule() {
        Pattern pattern = PATTERN_TIMESTAMP;
        d0.z.d.m.checkNotNullExpressionValue(pattern, "PATTERN_TIMESTAMP");
        return new Rules$createTimestampRule$1(this, pattern);
    }

    public final <T, S> Rule<T, c.a.t.b.a.a<T>, S> createUnescapeEmoticonRule() {
        Pattern pattern = PATTERN_UNESCAPE_EMOTICON;
        d0.z.d.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();
        d0.z.d.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;
        d0.z.d.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;
        d0.z.d.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;
        d0.z.d.m.checkNotNullExpressionValue(pattern, "PATTERN_MENTION");
        return new Rules$createUserMentionRule$1(this, pattern);
    }
}