ClearURLs — FiveCord

index.ts

Download

Source

src/plugins/clearURLs/index.ts

1import {

2 MessageObject

3} from "@api/MessageEvents";

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

5import definePlugin from "@utils/types";

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

9interface Provider {

10 urlPattern: string;

11 completeProvider: boolean;

12 rules?: string[];

13 rawRules?: string[];

14 referralMarketing?: string[];

15 exceptions?: string[];

16 redirections?: string[];

17 forceRedirection?: boolean;

18}

20interface ClearUrlsData {

21 providers: Record<string, Provider>;

22}

24interface RuleSet {

25 name: string;

26 urlPattern: RegExp;

27 rules?: RegExp[];

28 rawRules?: RegExp[];

29 exceptions?: RegExp[];

30}

32export default definePlugin({

33 name: "ClearURLs",

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

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

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

38 rules: [] as RuleSet[],

40 async start() {

41 await this.createRules();

42 },

44 stop() {

45 this.rules = [];

46 },

48 onBeforeMessageSend(_, msg) {

49 return this.cleanMessage(msg);

50 },

52 onBeforeMessageEdit(_cid, _mid, msg) {

53 return this.cleanMessage(msg);

54 },

56 async createRules() {

57 const res = await fetch(CLEAR_URLS_JSON_URL)

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

60 this.rules = [];

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

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

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

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

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

69 this.rules.push({

70 name,

71 urlPattern,

72 rules,

73 rawRules,

74 exceptions,

75 });

76 }

77 },

79 replacer(match: string) {

80 // Parse URL without throwing errors

81 try {

82 var url = new URL(match);

83 } catch (error) {

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

85 return match;

86 }

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

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

91 // Check rules for each provider that matches

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

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

95 const toDelete: string[] = [];

97 if (rules) {

98 // Add matched params to delete list

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

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

101 toDelete.push(param);

102 }

103 });

104 }

105

106 // Delete matched params from list

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

108

109 // Match and remove any raw rules

110 let cleanedUrl = url.href;

111 rawRules?.forEach(rawRule => {

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

113 });

114 url = new URL(cleanedUrl);

115 });

116

117 return url.toString();

118 },

119

120 cleanMessage(msg: MessageObject) {

121 // Only run on messages that contain URLs

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

123 msg.content = msg.content.replace(

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

125 match => this.replacer(match)

126 );

127 }

128 },

129});

130

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