@fsvreddit/bot-bouncer-evaluation 0.7.40

package/dist/userEvaluation/EvaluatePostTitleDefinedHandles.d.ts

@@ -0,0 +1,15 @@
+import { Post } from "@devvit/public-api";
+import { CommentCreate } from "@devvit/protos";
+import { EvaluatorRegex, UserEvaluatorBase, ValidationIssue } from "./UserEvaluatorBase.js";
+import { UserExtended } from "@fsvreddit/fsv-devvit-helpers";
+export declare class EvaluatePostTitleDefinedHandles extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    validateVariables(): ValidationIssue[];
+    gatherRegexes(): EvaluatorRegex[];
+    preEvaluateComment(_: CommentCreate): boolean;
+    preEvaluatePost(post: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(_: UserExtended): boolean;
+}

package/dist/userEvaluation/EvaluatePostTitleDefinedHandles.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluatePostTitleDefinedHandles = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const date_fns_1 = require("date-fns");
+const lodash_1 = require("lodash");
+const regjsparser_1 = require("regjsparser");
+const markdown_escape_1 = __importDefault(require("markdown-escape"));
+class EvaluatePostTitleDefinedHandles extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Bad Post Title Defined Handles Bot";
+        this.shortname = "posttitledefinedhandles";
+        this.banContentThreshold = 1;
+    }
+    validateVariables() {
+        const results = [];
+        let regexes;
+        try {
+            regexes = this.gatherRegexes().map(r => r.regex);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            results.push({ severity: "error", message: `Invalid defined handles list: ${message}` });
+            return results;
+        }
+        for (const regexVal of regexes) {
+            let regex;
+            try {
+                regex = new RegExp(regexVal, "u");
+            }
+            catch {
+                results.push({ severity: "error", message: `Invalid regex in post title: ${regexVal}` });
+                continue;
+            }
+            if (regex.test("")) {
+                results.push({ severity: "error", message: `Post title regex is too greedy: ${regexVal}` });
+            }
+        }
+        return results;
+    }
+    gatherRegexes() {
+        const prefix = this.getVariable("prefix", "");
+        const suffix = this.getVariable("suffix", "");
+        const definedHandles = this.getModuleVariable("substitutions", "definedhandles", "");
+        if (!definedHandles) {
+            return [];
+        }
+        const parsed = (0, regjsparser_1.parse)(definedHandles, "u");
+        if (parsed.type !== "disjunction") {
+            return [];
+        }
+        const regexes = parsed.body.map(part => `${prefix}${part.raw}${suffix}`);
+        return (0, lodash_1.uniq)(regexes.map(regex => ({
+            evaluatorName: this.name,
+            regex,
+            flags: "u",
+        })));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluateComment(_) {
+        return false;
+    }
+    preEvaluatePost(post) {
+        if (post.crosspostParentId) {
+            return false;
+        }
+        const problematicTitles = this.gatherRegexes().map(r => r.regex);
+        return problematicTitles.some(title => new RegExp(title, "u").test(post.title));
+    }
+    preEvaluateUser(user) {
+        const maxCommentKarma = this.getVariable("maxCommentKarma", 2000);
+        const maxLinkKarma = this.getVariable("maxLinkKarma", 5000);
+        if (user.commentKarma > maxCommentKarma && user.linkKarma > maxLinkKarma) {
+            return false;
+        }
+        return true;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    evaluate(_) {
+        const userPosts = this.getPosts({ since: (0, date_fns_1.subWeeks)(new Date(), 1) }).filter(post => post.isNsfw() && !post.crosspostParentId);
+        if (userPosts.length === 0) {
+            return false;
+        }
+        const regexes = this.gatherRegexes().map(r => ({ pattern: r.regex, regex: new RegExp(r.regex, r.flags) }));
+        if (regexes.length === 0) {
+            return false;
+        }
+        const nonMatchingTitles = new Set();
+        for (const title of userPosts.map(post => post.title)) {
+            if (nonMatchingTitles.has(title)) {
+                continue;
+            }
+            const matchedRegex = regexes.find(r => r.regex.test(title));
+            if (!matchedRegex) {
+                nonMatchingTitles.add(title);
+                continue;
+            }
+            this.addHitReason(`Post title "${title}" matched bannable regex: ${(0, markdown_escape_1.default)(matchedRegex.pattern)}`);
+            this.canAutoBan = true;
+            return true;
+        }
+        return false;
+    }
+}
+exports.EvaluatePostTitleDefinedHandles = EvaluatePostTitleDefinedHandles;

package/dist/userEvaluation/EvaluatePostTitleMulti.d.ts

@@ -0,0 +1,16 @@
+import { Post } from "@devvit/public-api";
+import { CommentCreate } from "@devvit/protos";
+import { EvaluatorRegex, UserEvaluatorBase, ValidationIssue } from "./UserEvaluatorBase.js";
+import { UserExtended } from "@fsvreddit/fsv-devvit-helpers";
+export declare class EvaluatePostTitleMulti extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    validateVariables(): ValidationIssue[];
+    getVariableOverrides(): Record<string, unknown>;
+    gatherRegexes(): EvaluatorRegex[];
+    preEvaluateComment(_: CommentCreate): boolean;
+    preEvaluatePost(post: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(_: UserExtended): boolean;
+}

package/dist/userEvaluation/EvaluatePostTitleMulti.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluatePostTitleMulti = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const date_fns_1 = require("date-fns");
+const lodash_1 = require("lodash");
+class EvaluatePostTitleMulti extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Bad Post Title Multi Bot";
+        this.shortname = "posttitlemulti";
+        this.banContentThreshold = 1;
+    }
+    validateVariables() {
+        const regexes = this.gatherRegexes();
+        const results = [];
+        for (const regexObj of regexes) {
+            let regex;
+            try {
+                regex = new RegExp(regexObj.regex, regexObj.flags);
+            }
+            catch {
+                results.push({ severity: "error", message: `Invalid regex: ${regexObj.regex}` });
+                continue;
+            }
+            if (!regexObj.regex.startsWith("^")) {
+                results.push({ severity: "warning", message: `Regex must be anchored to start with \`^\`: ${regexObj.regex}` });
+                continue;
+            }
+            if (regex.test("")) {
+                results.push({ severity: "error", message: `Regex is too greedy: ${regexObj.regex}` });
+            }
+        }
+        return results;
+    }
+    getVariableOverrides() {
+        const regexes = this.getVariable("regexes", []);
+        if (regexes.some(r => Array.isArray(r))) {
+            return {
+                regexes: regexes.flat(),
+            };
+        }
+        else {
+            return {};
+        }
+    }
+    gatherRegexes() {
+        const bannableTitles = this.getVariable("regexes", []);
+        return bannableTitles.map(title => ({
+            evaluatorName: this.name,
+            regex: title,
+            flags: "u",
+        }));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluateComment(_) {
+        return false;
+    }
+    preEvaluatePost(post) {
+        if (post.crosspostParentId) {
+            return false;
+        }
+        const regexes = this.gatherRegexes();
+        return regexes.some(regexObj => new RegExp(regexObj.regex, regexObj.flags).test(post.title));
+    }
+    preEvaluateUser(user) {
+        return user.nsfw;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    evaluate(_) {
+        const dateCutoff = this.getVariable("dateCutoffWeeks", 4);
+        const userPosts = this.getPosts({ since: (0, date_fns_1.subWeeks)(new Date(), dateCutoff) }).filter(post => post.nsfw && !post.crosspostParentId);
+        if (userPosts.length === 0) {
+            return false;
+        }
+        const distinctTitles = (0, lodash_1.uniq)(userPosts.map(post => post.title));
+        const regexes = this.gatherRegexes();
+        const matchedRegexes = regexes.filter(regexObj => distinctTitles.some(postTitle => new RegExp(regexObj.regex, regexObj.flags).test(postTitle)));
+        const matchesNeeded = this.getVariable("matchesNeeded", 4);
+        if (matchedRegexes.length < matchesNeeded) {
+            return false;
+        }
+        const regexesInOutput = this.getVariable("regexesInOutput", 5);
+        this.addHitReason(`User has ${matchedRegexes.length} bad post titles: ${matchedRegexes.slice(0, regexesInOutput).map(r => `\`${r.regex}\``).join(", ")}`);
+        return true;
+    }
+}
+exports.EvaluatePostTitleMulti = EvaluatePostTitleMulti;

package/dist/userEvaluation/EvaluateRapidFireBot.d.ts

@@ -0,0 +1,13 @@
+import { Comment, Post } from "@devvit/public-api";
+import { CommentCreate } from "@devvit/protos";
+import { UserEvaluatorBase } from "./UserEvaluatorBase.js";
+import { UserExtended } from "../extendedDevvit.js";
+export declare class EvaluateRapidFireBot extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    preEvaluateComment(_: CommentCreate): boolean;
+    preEvaluatePost(_: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(_: UserExtended, history: (Post | Comment)[]): boolean;
+}

package/dist/userEvaluation/EvaluateRapidFireBot.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateRapidFireBot = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const date_fns_1 = require("date-fns");
+class EvaluateRapidFireBot extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Rapid Fire Bot";
+        this.shortname = "rapidfire";
+        this.banContentThreshold = 5;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluateComment(_) {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluatePost(_) {
+        return true;
+    }
+    preEvaluateUser(user) {
+        if (user.commentKarma > this.getVariable("maxcommentkarma", 500)) {
+            return false;
+        }
+        if (user.linkKarma > this.getVariable("maxpostkarma", 500)) {
+            return false;
+        }
+        if (user.createdAt < (0, date_fns_1.subDays)(new Date(), this.getVariable("maxaccountageindays", 28))) {
+            return false;
+        }
+        return true;
+    }
+    evaluate(_, history) {
+        const sortedHistory = [...history.filter(item => item.createdAt > (0, date_fns_1.subMonths)(new Date(), 1))]
+            .sort((a, b) => a.createdAt > b.createdAt ? -1 : 1);
+        const periodInMinutes = this.getVariable("periodinminutes", 1);
+        const numberOfItems = this.getVariable("numberofitems", 10);
+        for (const item of sortedHistory) {
+            const itemsInPeriod = sortedHistory.filter(otherItem => otherItem.createdAt < item.createdAt && otherItem.createdAt > (0, date_fns_1.subMinutes)(item.createdAt, periodInMinutes));
+            if (itemsInPeriod.length >= numberOfItems) {
+                this.addHitReason(`User has ${itemsInPeriod.length} items in a ${periodInMinutes} minute period up to ${item.id}`);
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.EvaluateRapidFireBot = EvaluateRapidFireBot;

package/dist/userEvaluation/EvaluateRepostBot.d.ts

@@ -0,0 +1,19 @@
+import { Post } from "@devvit/public-api";
+import { CommentCreate } from "@devvit/protos";
+import { UserEvaluatorBase } from "./UserEvaluatorBase.js";
+import { UserExtended } from "@fsvreddit/fsv-devvit-helpers";
+export declare class EvaluateRepostBot extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    needsOpenAiKey: boolean;
+    private minWordsInTitle;
+    private isEligiblePost;
+    preEvaluatePost(post: Post): boolean;
+    preEvaluateComment(_: CommentCreate): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    private getImageUrl;
+    private postIdToUrl;
+    private getPostSimilarity;
+    evaluate(user: UserExtended): Promise<boolean>;
+}

package/dist/userEvaluation/EvaluateRepostBot.js

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateRepostBot = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const evaluatorHelpers_js_1 = require("./evaluatorHelpers.js");
+const date_fns_1 = require("date-fns");
+const openai_1 = __importDefault(require("openai"));
+const zod_1 = __importDefault(require("zod"));
+const zod_js_1 = require("openai/helpers/zod.js");
+const constants_js_1 = require("../constants.js");
+const wordcount_1 = require("@wordpress/wordcount");
+class EvaluateRepostBot extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Repost Bot";
+        this.shortname = "repost";
+        this.banContentThreshold = 1;
+        this.needsOpenAiKey = true;
+    }
+    isEligiblePost(post) {
+        if (post.nsfw || post.crosspostParentId) {
+            return false;
+        }
+        this.minWordsInTitle ?? (this.minWordsInTitle = this.getVariable("minWordsInTitle", 2));
+        if ((0, wordcount_1.count)(post.title, "words") < this.minWordsInTitle) {
+            return false;
+        }
+        return (0, evaluatorHelpers_js_1.domainFromUrl)(post.url) === "i.redd.it" || post.gallery.length > 0;
+    }
+    preEvaluatePost(post) {
+        return this.isEligiblePost(post);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluateComment(_) {
+        return false;
+    }
+    preEvaluateUser(user) {
+        const maxAgeInMonths = this.getVariable("maxAgeInMonths", 1);
+        return user.createdAt > (0, date_fns_1.subMonths)(new Date(), maxAgeInMonths);
+    }
+    getImageUrl(post) {
+        if (post.gallery.length > 0) {
+            return post.gallery[0].url;
+        }
+        return post.url;
+    }
+    postIdToUrl(postId) {
+        return `https://redd.it/${postId.substring(3)}`;
+    }
+    async getPostSimilarity(postA, postB) {
+        const cacheKey = `bbe:RepostBot:similarity:${postA.id}:${postB.id}`;
+        const redis = this.context.appSlug === constants_js_1.MAIN_APP_NAME ? this.context.redis.global : this.context.redis;
+        const cachedResult = await redis.get(cacheKey);
+        if (cachedResult) {
+            console.log(`Repost Checks: Using cached similarity between ${this.postIdToUrl(postA.id)} and ${this.postIdToUrl(postB.id)}: ${cachedResult}`);
+            return parseFloat(cachedResult);
+        }
+        const openAI = new openai_1.default({ apiKey: this.openAiKey });
+        const responseFormat = zod_1.default.object({
+            similarity: zod_1.default.number().min(0).max(1),
+        });
+        const prompt = this.getVariable("prompt", "You are provided with the URLs of two images. Your task is to determine how visually similar they are. Return the similarity from 0 to 1, where 0 is completely different and 1 is identical. Only return the similarity as a number in JSON format, do not include any other text.");
+        const content = [
+            {
+                type: "input_text",
+                text: prompt,
+            },
+            {
+                type: "input_image",
+                // eslint-disable-next-line camelcase
+                image_url: this.getImageUrl(postA),
+                detail: "low",
+            },
+            {
+                type: "input_image",
+                // eslint-disable-next-line camelcase
+                image_url: this.getImageUrl(postB),
+                detail: "low",
+            },
+        ];
+        try {
+            const response = await openAI.responses.create({
+                model: this.getVariable("openAiModel", "gpt-5.4-nano"),
+                input: [
+                    {
+                        role: "user",
+                        content,
+                    },
+                ],
+                text: {
+                    format: (0, zod_js_1.zodTextFormat)(responseFormat, "similarity"),
+                },
+            });
+            const result = JSON.parse(response.output_text);
+            await redis.set(cacheKey, result.similarity.toString(), { expiration: (0, date_fns_1.addHours)(new Date(), 1) });
+            console.log(`Repost Checks: Tokens used: ${response.usage?.total_tokens}, Similarity between ${this.postIdToUrl(postA.id)} and ${this.postIdToUrl(postB.id)}: ${result.similarity}`);
+            return result.similarity;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Error getting post similarity for ${postA.id}: ${message}`);
+            return;
+        }
+    }
+    async evaluate(user) {
+        if (!this.preEvaluateUser(user)) {
+            return false;
+        }
+        const comments = this.getComments();
+        const maxCommentCount = this.getVariable("maxCommentCount", 5);
+        if (comments.length > maxCommentCount) {
+            return false;
+        }
+        const posts = this.getPosts();
+        if (posts.some(post => !this.isEligiblePost(post))) {
+            return false;
+        }
+        if (posts.length === 0) {
+            return false;
+        }
+        const maxPostCount = this.getVariable("maxPostCount", 5);
+        if (posts.length > maxPostCount) {
+            return false;
+        }
+        // Sort posts, latest first
+        const sortedPosts = posts.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        const latestPost = sortedPosts[0];
+        // Look for duplicate posts.
+        const postDuplicates = await this.context.reddit.searchPosts({
+            query: `title:"${latestPost.title}"`,
+            subredditName: latestPost.subredditName,
+            sort: "new",
+            limit: 100,
+        }).all().then(posts => posts.filter(post => this.isEligiblePost(post) && post.title === latestPost.title && post.authorName !== latestPost.authorName));
+        if (postDuplicates.length === 0) {
+            return false;
+        }
+        const maxDuplicatePostCount = this.getVariable("maxDuplicatePostCount", 50);
+        if (postDuplicates.length > maxDuplicatePostCount) {
+            return false;
+        }
+        // Sort duplicates, oldest first
+        postDuplicates.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+        const oldestDuplicate = postDuplicates[0];
+        if (oldestDuplicate.createdAt > latestPost.createdAt) {
+            return false;
+        }
+        const minDuplicateAgeInDays = this.getVariable("minDuplicateAgeInDays", 7);
+        if (oldestDuplicate.createdAt > (0, date_fns_1.subDays)(new Date(), minDuplicateAgeInDays)) {
+            return false;
+        }
+        const similarityNeeded = this.getVariable("similarityNeeded", 0.9);
+        const postSimilarity = await this.getPostSimilarity(latestPost, oldestDuplicate);
+        if (postSimilarity === undefined) {
+            return false;
+        }
+        if (postSimilarity < similarityNeeded) {
+            return false;
+        }
+        this.addHitReason(`User's post ${this.postIdToUrl(latestPost.id)} is a repost of ${this.postIdToUrl(oldestDuplicate.id)} with similarity ${Math.round(postSimilarity * 100)}%`);
+        return true;
+    }
+}
+exports.EvaluateRepostBot = EvaluateRepostBot;

package/dist/userEvaluation/EvaluateSelfComment.d.ts

@@ -0,0 +1,16 @@
+import { CommentCreate } from "@devvit/protos";
+import { UserEvaluatorBase } from "./UserEvaluatorBase.js";
+import { Post } from "@devvit/public-api";
+import { UserExtended } from "@fsvreddit/fsv-devvit-helpers";
+export declare class EvaluateSelfComment extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    private isSubIgnored;
+    private eligibleComment;
+    private eligiblePost;
+    preEvaluateComment(event: CommentCreate): boolean;
+    preEvaluatePost(post: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(user: UserExtended): boolean;
+}

package/dist/userEvaluation/EvaluateSelfComment.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateSelfComment = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const date_fns_1 = require("date-fns");
+const tid_js_1 = require("@devvit/public-api/types/tid.js");
+const evaluatorHelpers_js_1 = require("./evaluatorHelpers.js");
+class EvaluateSelfComment extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Self Comment";
+        this.shortname = "selfcomment";
+        this.banContentThreshold = 2;
+    }
+    isSubIgnored() {
+        const ignoredSubreddits = this.getVariable("ignoredsubs", []);
+        return this.context.subredditName && ignoredSubreddits.includes(this.context.subredditName);
+    }
+    eligibleComment(comment) {
+        return (0, tid_js_1.isLinkId)(comment.parentId)
+            && comment.body.split("\n\n").length <= 2;
+    }
+    eligiblePost(post) {
+        const domain = (0, evaluatorHelpers_js_1.domainFromUrl)(post.url);
+        const karmaFarmingSubs = this.getGenericVariable("karmafarminglinksubs", []);
+        return (domain === "i.redd.it" || domain === "v.redd.it") && !post.nsfw && karmaFarmingSubs.includes(post.subredditName);
+    }
+    preEvaluateComment(event) {
+        if (this.isSubIgnored()) {
+            return false;
+        }
+        if (!event.comment || !event.author) {
+            return false;
+        }
+        return event.post?.authorId === event.author.id && this.eligibleComment(event.comment);
+    }
+    preEvaluatePost(post) {
+        if (this.isSubIgnored()) {
+            return false;
+        }
+        return this.eligiblePost(post);
+    }
+    preEvaluateUser(user) {
+        const ageInDays = this.getVariable("ageindays", 14);
+        const maxKarma = this.getVariable("maxkarma", 500);
+        return user.createdAt > (0, date_fns_1.subDays)(new Date(), ageInDays) && user.commentKarma < maxKarma;
+    }
+    evaluate(user) {
+        const ignoredSubreddits = this.getVariable("ignoredsubs", []);
+        const posts = this.getPosts({ omitRemoved: true }).filter(post => !ignoredSubreddits.includes(post.subredditName) && !post.subredditName.toLowerCase().includes("onlyfans"));
+        if (posts.length === 0 || !posts.every(post => this.eligiblePost(post))) {
+            return false;
+        }
+        const comments = this.getComments();
+        if (comments.length === 0 || !comments.every(comment => this.eligibleComment(comment))) {
+            return false;
+        }
+        if (!posts.some(post => comments.some(comment => comment.parentId === post.id && !ignoredSubreddits.includes(post.subredditName)))) {
+            return false;
+        }
+        const maxCommentAge = this.getVariable("commentmaxminutes", 1);
+        for (const comment of comments.filter(comment => !ignoredSubreddits.includes(comment.subredditName))) {
+            const post = posts.find(post => post.id === comment.parentId);
+            if (post?.authorId !== user.id) {
+                return false;
+            }
+            if (comment.createdAt > (0, date_fns_1.addMinutes)(post.createdAt, maxCommentAge)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.EvaluateSelfComment = EvaluateSelfComment;

package/dist/userEvaluation/EvaluateSocialLinks.d.ts

@@ -0,0 +1,16 @@
+import { Post } from "@devvit/public-api";
+import { CommentCreate } from "@devvit/protos";
+import { UserEvaluatorBase, ValidationIssue } from "./UserEvaluatorBase.js";
+import { UserExtended } from "@fsvreddit/fsv-devvit-helpers";
+export declare class EvaluateSocialLinks extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    validateVariables(): ValidationIssue[];
+    getVariableOverrides(): Record<string, unknown>;
+    private getDomains;
+    preEvaluateComment(_: CommentCreate): boolean;
+    preEvaluatePost(post: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(user: UserExtended): Promise<boolean>;
+}