ClearURLs — FiveCord

index.ts

Download

Source

src/plugins/clearURLs/index.ts

1/*

2 * FiveCord — a Discord client mod

4 * SPDX-License-Identifier: GPL-3.0-or-later

5 */

7import {

8 MessageObject

9} from "@api/MessageEvents";

10import { Devs } from "@utils/constants";

11import definePlugin from "@utils/types";

13const CLEAR_URLS_JSON_URL = "https:class="ts-cmt">//raw.githubusercontent.com/ClearURLs/Rules/master/data.min.json";

15interface Provider {

16 urlPattern: string;

17 completeProvider: boolean;

18 rules?: string[];

19 rawRules?: string[];

20 referralMarketing?: string[];

21 exceptions?: string[];

22 redirections?: string[];

23 forceRedirection?: boolean;

24}

26interface ClearUrlsData {

27 providers: Record<string, Provider>;

28}

30interface RuleSet {

31 name: string;

32 urlPattern: RegExp;

33 rules?: RegExp[];

34 rawRules?: RegExp[];

35 exceptions?: RegExp[];

36}

38export default definePlugin({

39 name: "ClearURLs",

40 description: "Automatically removes tracking elements from URLs you send",

41 tags: ["Privacy", "Utility"],

42 authors: [Devs.adryd, Devs.thororen],

44 rules: [] as RuleSet[],

46 async start() {

47 await this.createRules();

48 },

50 stop() {

51 this.rules = [];

52 },

54 onBeforeMessageSend(_, msg) {

55 return this.cleanMessage(msg);

56 },

58 onBeforeMessageEdit(_cid, _mid, msg) {

59 return this.cleanMessage(msg);

60 },

62 async createRules() {

63 const res = await fetch(CLEAR_URLS_JSON_URL)

64 .then(res => res.json()) as ClearUrlsData;

66 this.rules = [];

68 for (const [name, provider] of Object.entries(res.providers)) {

69 const urlPattern = new RegExp(provider.urlPattern, "i");

71 const rules = provider.rules?.map(rule => new RegExp(rule, "i"));

72 const rawRules = provider.rawRules?.map(rule => new RegExp(rule, "i"));

73 const exceptions = provider.exceptions?.map(ex => new RegExp(ex, "i"));

75 this.rules.push({

76 name,

77 urlPattern,

78 rules,

79 rawRules,

80 exceptions,

81 });

82 }

83 },

85 replacer(match: string) {

86 // Parse URL without throwing errors

87 try {

88 var url = new URL(match);

89 } catch (error) {

90 // Don't modify anything if we can't parse the URL

91 return match;

92 }

94 // Cheap way to check if there are any search params

95 if (url.searchParams.entries().next().done) return match;

97 // Check rules for each provider that matches

98 this.rules.forEach(({ urlPattern, exceptions, rawRules, rules }) => {

99 if (!urlPattern.test(url.href) || exceptions?.some(ex => ex.test(url.href))) return;

100

101 const toDelete: string[] = [];

102

103 if (rules) {

104 // Add matched params to delete list

105 url.searchParams.forEach((_, param) => {

106 if (rules.some(rule => rule.test(param))) {

107 toDelete.push(param);

108 }

109 });

110 }

111

112 // Delete matched params from list

113 toDelete.forEach(param => url.searchParams.delete(param));

114

115 // Match and remove any raw rules

116 let cleanedUrl = url.href;

117 rawRules?.forEach(rawRule => {

118 cleanedUrl = cleanedUrl.replace(rawRule, "");

119 });

120 url = new URL(cleanedUrl);

121 });

122

123 return url.toString();

124 },

125

126 cleanMessage(msg: MessageObject) {

127 // Only run on messages that contain URLs

128 if (/http(s)?:\/\class="ts-cmt">//.test(msg.content)) {

129 msg.content = msg.content.replace(

130 /(https?:\/\/[^\s<]+[^<.,:;"'>)|\]\s])/g,

131 match => this.replacer(match)

132 );

133 }

134 },

135});

136

/*
 * FiveCord — a Discord client mod
 * Copyright (c) 2025 FiveCord
 * SPDX-License-Identifier: GPL-3.0-or-later
 */

import {
    MessageObject
} from "@api/MessageEvents";
import { Devs } from "@utils/constants";
import definePlugin from "@utils/types";

const CLEAR_URLS_JSON_URL = "https://raw.githubusercontent.com/ClearURLs/Rules/master/data.min.json";

interface Provider {
    urlPattern: string;
    completeProvider: boolean;
    rules?: string[];
    rawRules?: string[];
    referralMarketing?: string[];
    exceptions?: string[];
    redirections?: string[];
    forceRedirection?: boolean;
}

interface ClearUrlsData {
    providers: Record<string, Provider>;
}

interface RuleSet {
    name: string;
    urlPattern: RegExp;
    rules?: RegExp[];
    rawRules?: RegExp[];
    exceptions?: RegExp[];
}

export default definePlugin({
    name: "ClearURLs",
    description: "Automatically removes tracking elements from URLs you send",
    tags: ["Privacy", "Utility"],
    authors: [Devs.adryd, Devs.thororen],

    rules: [] as RuleSet[],

    async start() {
        await this.createRules();
    },

    stop() {
        this.rules = [];
    },

    onBeforeMessageSend(_, msg) {
        return this.cleanMessage(msg);
    },

    onBeforeMessageEdit(_cid, _mid, msg) {
        return this.cleanMessage(msg);
    },

    async createRules() {
        const res = await fetch(CLEAR_URLS_JSON_URL)
            .then(res => res.json()) as ClearUrlsData;

        this.rules = [];

        for (const [name, provider] of Object.entries(res.providers)) {
            const urlPattern = new RegExp(provider.urlPattern, "i");

            const rules = provider.rules?.map(rule => new RegExp(rule, "i"));
            const rawRules = provider.rawRules?.map(rule => new RegExp(rule, "i"));
            const exceptions = provider.exceptions?.map(ex => new RegExp(ex, "i"));

            this.rules.push({
                name,
                urlPattern,
                rules,
                rawRules,
                exceptions,
            });
        }
    },

    replacer(match: string) {
        // Parse URL without throwing errors
        try {
            var url = new URL(match);
        } catch (error) {
            // Don't modify anything if we can't parse the URL
            return match;
        }

        // Cheap way to check if there are any search params
        if (url.searchParams.entries().next().done) return match;

        // Check rules for each provider that matches
        this.rules.forEach(({ urlPattern, exceptions, rawRules, rules }) => {
            if (!urlPattern.test(url.href) || exceptions?.some(ex => ex.test(url.href))) return;

            const toDelete: string[] = [];

            if (rules) {
                // Add matched params to delete list
                url.searchParams.forEach((_, param) => {
                    if (rules.some(rule => rule.test(param))) {
                        toDelete.push(param);
                    }
                });
            }

            // Delete matched params from list
            toDelete.forEach(param => url.searchParams.delete(param));

            // Match and remove any raw rules
            let cleanedUrl = url.href;
            rawRules?.forEach(rawRule => {
                cleanedUrl = cleanedUrl.replace(rawRule, "");
            });
            url = new URL(cleanedUrl);
        });

        return url.toString();
    },

    cleanMessage(msg: MessageObject) {
        // Only run on messages that contain URLs
        if (/http(s)?:\/\//.test(msg.content)) {
            msg.content = msg.content.replace(
                /(https?:\/\/[^\s<]+[^<.,:;"'>)|\]\s])/g,
                match => this.replacer(match)
            );
        }
    },
});

Source

FiveCord for Windows