commit 141fb93529fe375a3dfbde43ed1a9ac48cff2f67 · notnite.com/moonlight

+2 -1

packages/browser/blockLoading.json

···

       6
        
             "type": "block"

     

       7
        
           },

     

       8
        
           "condition": {

     

       9
       -
             "urlFilter": "*://discord.com/assets/*.js",

     

       0
        
       
     

       10
        
             "resourceTypes": ["script"]

     

       11
        
           }

     

       12
        
         }

···

       6
        
             "type": "block"

     

       7
        
           },

     

       8
        
           "condition": {

     

       9
       +
             "requestDomains": ["discord.com", "discordapp.com"],

     

       10
       +
             "urlFilter": "*/assets/*.js",

     

       11
        
             "resourceTypes": ["script"]

     

       12
        
           }

     

       13
        
         }

+8 -3

packages/browser/manifest.json

···

       5
        
         "description": "Yet another Discord mod",

     

       6
        
         "version": "1.3.11",

     

       7
        
         "permissions": ["declarativeNetRequestWithHostAccess", "webRequest", "scripting", "webNavigation"],

     

       8
       -
         "host_permissions": ["https://moonlight-mod.github.io/*", "https://api.github.com/*", "https://*.discord.com/*"],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       9
        
         "content_scripts": [

     

       10
        
           {

     

       11
        
             "js": ["index.js"],

     

       12
       -
             "matches": ["https://*.discord.com/*"],

     

       13
        
             "run_at": "document_start",

     

       14
        
             "world": "MAIN"

     

       15
        
           }

     
···

       35
        
         "web_accessible_resources": [

     

       36
        
           {

     

       37
        
             "resources": ["index.js"],

     

       38
       -
             "matches": ["https://*.discord.com/*"]

     

       39
        
           }

     

       40
        
         ]

     

       41
        
       }

···

       5
        
         "description": "Yet another Discord mod",

     

       6
        
         "version": "1.3.11",

     

       7
        
         "permissions": ["declarativeNetRequestWithHostAccess", "webRequest", "scripting", "webNavigation"],

     

       8
       +
         "host_permissions": [

     

       9
       +
           "https://moonlight-mod.github.io/*",

     

       10
       +
           "https://api.github.com/*",

     

       11
       +
           "https://*.discord.com/*",

     

       12
       +
           "https://*.discordapp.com/*"

     

       13
       +
         ],

     

       14
        
         "content_scripts": [

     

       15
        
           {

     

       16
        
             "js": ["index.js"],

     

       17
       +
             "matches": ["https://*.discord.com/*", "https://*.discordapp.com/*"],

     

       18
        
             "run_at": "document_start",

     

       19
        
             "world": "MAIN"

     

       20
        
           }

     
···

       40
        
         "web_accessible_resources": [

     

       41
        
           {

     

       42
        
             "resources": ["index.js"],

     

       43
       +
             "matches": ["https://*.discord.com/*", "https://*.discordapp.com/*"]

     

       44
        
           }

     

       45
        
         ]

     

       46
        
       }

+4 -4

packages/browser/manifestv2.json

···

       9
        
           "webRequestBlocking",

     

       10
        
           "scripting",

     

       11
        
           "webNavigation",

     

       12
       -
           "https://*.discord.com/assets/*.js",

     

       0
        
       
     

       13
        
           "https://moonlight-mod.github.io/*",

     

       14
       -
           "https://api.github.com/*",

     

       15
       -
           "https://*.discord.com/*"

     

       16
        
         ],

     

       17
        
         "background": {

     

       18
        
           "scripts": ["background.js"]

     
···

       20
        
         "content_scripts": [

     

       21
        
           {

     

       22
        
             "js": ["index.js"],

     

       23
       -
             "matches": ["https://*.discord.com/*"],

     

       24
        
             "run_at": "document_start",

     

       25
        
             "world": "MAIN"

     

       26
        
           }

···

       9
        
           "webRequestBlocking",

     

       10
        
           "scripting",

     

       11
        
           "webNavigation",

     

       12
       +
           "https://*.discord.com/*",

     

       13
       +
           "https://*.discordapp.com/*",

     

       14
        
           "https://moonlight-mod.github.io/*",

     

       15
       +
           "https://api.github.com/*"

     

       0
        
       
     

       16
        
         ],

     

       17
        
         "background": {

     

       18
        
           "scripts": ["background.js"]

     
···

       20
        
         "content_scripts": [

     

       21
        
           {

     

       22
        
             "js": ["index.js"],

     

       23
       +
             "matches": ["https://*.discord.com/*", "https://*.discordapp.com/*"],

     

       24
        
             "run_at": "document_start",

     

       25
        
             "world": "MAIN"

     

       26
        
           }

+55 -70

packages/browser/src/background-mv2.js

···

       1
        
       /* eslint-disable no-console */

     

       2
        
       /* eslint-disable no-undef */

     

       3
        
       

     

       4
       -
       const starterUrls = ["web.", "sentry."];

     

       5
       -
       let blockLoading = true;

     

       6
       -
       let doing = false;

     

       7
       -
       let collectedUrls = new Set();

     

       8
        
       

     

       9
       -
       chrome.webNavigation.onBeforeNavigate.addListener(async (details) => {

     

       10
       -
         const url = new URL(details.url);

     

       11
       -
         if (!blockLoading && url.hostname.endsWith("discord.com")) {

     

       12
       -
           console.log("Blocking", details.url);

     

       13
       -
           blockLoading = true;

     

       14
       -
           collectedUrls.clear();

     

       15
       -
         }

     

       16
       -
       });

     

       17
        
       

     

       18
       -
       async function doTheThing(urls, tabId) {

     

       19
       -
         console.log("Doing", urls, tabId);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       20
        
       

     

       21
       -
         blockLoading = false;

     

       0
        
       
     

       0
        
       
     

       22
        
       

     

       23
       -
         try {

     

       24
       -
           await chrome.scripting.executeScript({

     

       25
       -
             target: { tabId },

     

       26
       -
             world: "MAIN",

     

       27
       -
             args: [urls],

     

       28
       -
             func: async (urls) => {

     

       29
       -
               try {

     

       30
       -
                 await window._moonlightBrowserInit();

     

       31
       -
               } catch (e) {

     

       32
       -
                 console.log(e);

     

       33
       -
               }

     

       0
        
       
     

       0
        
       
     

       34
        
       

     

       35
       -
               const scripts = [...document.querySelectorAll("script")].filter(

     

       36
       -
                 (script) => script.src && urls.some((url) => url.includes(script.src))

     

       37
       -
               );

     

       0
        
       
     

       0
        
       
     

       38
        
       

     

       39
       -
               // backwards

     

       40
       -
               urls.reverse();

     

       41
       -
               for (const url of urls) {

     

       42
       -
                 const script = scripts.find((script) => url.includes(script.src));

     

       43
       -
                 console.log("adding new script", script);

     

       44
        
       

     

       45
       -
                 const newScript = document.createElement("script");

     

       46
       -
                 for (const { name, value } of script.attributes) {

     

       47
       -
                   newScript.setAttribute(name, value);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       48
        
                 }

     

       49
       -
       

     

       50
       -
                 script.remove();

     

       51
       -
                 document.documentElement.appendChild(newScript);

     

       52
       -
               }

     

       53
       -
             }

     

       54
       -
           });

     

       55
       -
         } catch (e) {

     

       56
       -
           console.log(e);

     

       57
       -
         }

     

       58
       -
       

     

       59
       -
         doing = false;

     

       60
       -
         collectedUrls.clear();

     

       61
       -
       }

     

       62
       -
       

     

       63
       -
       chrome.webRequest.onBeforeRequest.addListener(

     

       64
       -
         async (details) => {

     

       65
       -
           if (starterUrls.some((url) => details.url.includes(url))) {

     

       66
       -
             console.log("Adding", details.url);

     

       67
       -
             collectedUrls.add(details.url);

     

       68
        
           }

     

       69
        
       

     

       70
       -
           if (collectedUrls.size === starterUrls.length) {

     

       71
       -
             if (doing) return;

     

       72
       -
             if (!blockLoading) return;

     

       73
       -
             doing = true;

     

       74
       -
             const urls = [...collectedUrls];

     

       75
       -
             const tabId = details.tabId;

     

       76
       -
       

     

       77
       -
             // yes this is a load-bearing sleep

     

       78
       -
             setTimeout(() => doTheThing(urls, tabId), 0);

     

       79
       -
           }

     

       80
       -
       

     

       81
       -
           if (blockLoading) return { cancel: true };

     

       82
        
         },

     

       83
        
         {

     

       84
       -
           urls: ["https://*.discord.com/assets/*.js"]

     

       85
        
         },

     

       86
        
         ["blocking"]

     

       87
        
       );

     
···

       94
        
             )

     

       95
        
           };

     

       96
        
         },

     

       97
       -
         { urls: ["https://*.discord.com/*"] },

     

       98
        
         ["blocking", "responseHeaders"]

     

       99
        
       );

···

       1
        
       /* eslint-disable no-console */

     

       2
        
       /* eslint-disable no-undef */

     

       3
        
       

     

       4
       +
       const scriptUrls = ["web.", "sentry."];

     

       5
       +
       let blockedScripts = new Set();

     

       0
        
       
     

       0
        
       
     

       6
        
       

     

       7
       +
       chrome.webRequest.onBeforeRequest.addListener(

     

       8
       +
         async (details) => {

     

       9
       +
           if (details.tabId === -1) return;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       10
        
       

     

       11
       +
           const url = new URL(details.url);

     

       12
       +
           const hasUrl = scriptUrls.some((scriptUrl) => {

     

       13
       +
             return (

     

       14
       +
               details.url.includes(scriptUrl) &&

     

       15
       +
               !url.searchParams.has("inj") &&

     

       16
       +
               (url.host.endsWith("discord.com") || url.host.endsWith("discordapp.com"))

     

       17
       +
             );

     

       18
       +
           });

     

       19
       +
           if (hasUrl) blockedScripts.add(details.url);

     

       20
        
       

     

       21
       +
           if (blockedScripts.size === scriptUrls.length) {

     

       22
       +
             const blockedScriptsCopy = Array.from(blockedScripts);

     

       23
       +
             blockedScripts.clear();

     

       24
        
       

     

       25
       +
             setTimeout(async () => {

     

       26
       +
               console.log("Starting moonlight");

     

       27
       +
               await chrome.scripting.executeScript({

     

       28
       +
                 target: { tabId: details.tabId },

     

       29
       +
                 world: "MAIN",

     

       30
       +
                 args: [blockedScriptsCopy],

     

       31
       +
                 func: async (blockedScripts) => {

     

       32
       +
                   console.log("Initializing moonlight");

     

       33
       +
                   try {

     

       34
       +
                     await window._moonlightBrowserInit();

     

       35
       +
                   } catch (e) {

     

       36
       +
                     console.error(e);

     

       37
       +
                   }

     

       38
        
       

     

       39
       +
                   console.log("Readding scripts");

     

       40
       +
                   try {

     

       41
       +
                     const scripts = [...document.querySelectorAll("script")].filter(

     

       42
       +
                       (script) => script.src && blockedScripts.some((url) => url.includes(script.src))

     

       43
       +
                     );

     

       44
        
       

     

       45
       +
                     blockedScripts.reverse();

     

       46
       +
                     for (const url of blockedScripts) {

     

       47
       +
                       if (url.includes("/sentry.")) continue;

     

       0
        
       
     

       0
        
       
     

       48
        
       

     

       49
       +
                       const script = scripts.find((script) => url.includes(script.src));

     

       50
       +
                       const newScript = document.createElement("script");

     

       51
       +
                       for (const attr of script.attributes) {

     

       52
       +
                         if (attr.name === "src") attr.value += "?inj";

     

       53
       +
                         newScript.setAttribute(attr.name, attr.value);

     

       54
       +
                       }

     

       55
       +
                       script.remove();

     

       56
       +
                       document.documentElement.appendChild(newScript);

     

       57
       +
                     }

     

       58
       +
                   } catch (e) {

     

       59
       +
                     console.error(e);

     

       60
       +
                   }

     

       61
        
                 }

     

       62
       +
               });

     

       63
       +
             }, 0);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       64
        
           }

     

       65
        
       

     

       66
       +
           if (hasUrl) return { cancel: true };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       67
        
         },

     

       68
        
         {

     

       69
       +
           urls: ["https://*.discord.com/assets/*.js", "https://*.discordapp.com/assets/*.js"]

     

       70
        
         },

     

       71
        
         ["blocking"]

     

       72
        
       );

     
···

       79
        
             )

     

       80
        
           };

     

       81
        
         },

     

       82
       +
         { urls: ["https://*.discord.com/*", "https://*.discordapp.com/*"] },

     

       83
        
         ["blocking", "responseHeaders"]

     

       84
        
       );

+37 -39

packages/browser/src/background.js

···

       1
        
       /* eslint-disable no-console */

     

       2
        
       /* eslint-disable no-undef */

     

       3
        
       

     

       4
       -
       const starterUrls = ["web.", "sentry."];

     

       5
       -
       let blockLoading = true;

     

       6
       -
       let doing = false;

     

       7
       -
       let collectedUrls = new Set();

     

       8
        
       

     

       9
        
       chrome.webNavigation.onBeforeNavigate.addListener(async (details) => {

     

       10
        
         const url = new URL(details.url);

     

       11
       -
         if (!blockLoading && url.hostname.endsWith("discord.com")) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       12
        
           await chrome.declarativeNetRequest.updateEnabledRulesets({

     

       13
        
             enableRulesetIds: ["modifyResponseHeaders", "blockLoading"]

     

       14
        
           });

     

       15
       -
           blockLoading = true;

     

       16
       -
           collectedUrls.clear();

     

       17
        
         }

     

       18
        
       });

     

       19
        
       

     

       20
        
       chrome.webRequest.onBeforeRequest.addListener(

     

       21
        
         async (details) => {

     

       22
        
           if (details.tabId === -1) return;

     

       23
       -
           if (starterUrls.some((url) => details.url.includes(url))) {

     

       24
       -
             console.log("Adding", details.url);

     

       25
       -
             collectedUrls.add(details.url);

     

       26
       -
           }

     

       27
        
       

     

       28
       -
           if (collectedUrls.size === starterUrls.length) {

     

       29
       -
             if (doing) return;

     

       30
       -
             if (!blockLoading) return;

     

       31
       -
             doing = true;

     

       32
       -
             const urls = [...collectedUrls];

     

       33
       -
             console.log("Doing", urls);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       34
        
       

     

       35
        
             console.log("Running moonlight script");

     

       36
        
             try {

     
···

       40
        
                 files: ["index.js"]

     

       41
        
               });

     

       42
        
             } catch (e) {

     

       43
       -
               console.log(e);

     

       44
        
             }

     

       45
        
       

     

       46
        
             console.log("Initializing moonlight");

     
···

       52
        
                   try {

     

       53
        
                     await window._moonlightBrowserInit();

     

       54
        
                   } catch (e) {

     

       55
       -
                     console.log(e);

     

       56
        
                   }

     

       57
        
                 }

     

       58
        
               });

     
···

       60
        
               console.log(e);

     

       61
        
             }

     

       62
        
       

     

       63
       -
             console.log("Updating rulesets");

     

       64
        
             try {

     

       65
       -
               blockLoading = false;

     

       66
        
               await chrome.declarativeNetRequest.updateEnabledRulesets({

     

       67
        
                 disableRulesetIds: ["blockLoading"],

     

       68
        
                 enableRulesetIds: ["modifyResponseHeaders"]

     

       69
        
               });

     

       70
        
             } catch (e) {

     

       71
       -
               console.log(e);

     

       72
        
             }

     

       73
        
       

     

       74
        
             console.log("Readding scripts");

     
···

       76
        
               await chrome.scripting.executeScript({

     

       77
        
                 target: { tabId: details.tabId },

     

       78
        
                 world: "MAIN",

     

       79
       -
                 args: [urls],

     

       80
       -
                 func: async (urls) => {

     

       81
        
                   const scripts = [...document.querySelectorAll("script")].filter(

     

       82
       -
                     (script) => script.src && urls.some((url) => url.includes(script.src))

     

       83
        
                   );

     

       84
        
       

     

       85
       -
                   // backwards

     

       86
       -
                   urls.reverse();

     

       87
       -
                   for (const url of urls) {

     

       88
       -
                     const script = scripts.find((script) => url.includes(script.src));

     

       89
       -
                     console.log("adding new script", script);

     

       90
        
       

     

       0
        
       
     

       91
        
                     const newScript = document.createElement("script");

     

       92
       -
                     for (const { name, value } of script.attributes) {

     

       93
       -
                       newScript.setAttribute(name, value);

     

       0
        
       
     

       94
        
                     }

     

       95
       -
       

     

       96
        
                     script.remove();

     

       97
        
                     document.documentElement.appendChild(newScript);

     

       98
        
                   }

     

       99
        
                 }

     

       100
        
               });

     

       101
        
             } catch (e) {

     

       102
       -
               console.log(e);

     

       103
        
             }

     

       104
       -
       

     

       105
       -
             console.log("Done");

     

       106
       -
             doing = false;

     

       107
       -
             collectedUrls.clear();

     

       108
        
           }

     

       109
        
         },

     

       110
        
         {

     

       111
       -
           urls: ["*://*.discord.com/assets/*.js"]

     

       112
        
         }

     

       113
        
       );

···

       1
        
       /* eslint-disable no-console */

     

       2
        
       /* eslint-disable no-undef */

     

       3
        
       

     

       4
       +
       const scriptUrls = ["web.", "sentry."];

     

       5
       +
       let blockedScripts = new Set();

     

       0
        
       
     

       0
        
       
     

       6
        
       

     

       7
        
       chrome.webNavigation.onBeforeNavigate.addListener(async (details) => {

     

       8
        
         const url = new URL(details.url);

     

       9
       +
         if (

     

       10
       +
           !url.searchParams.has("inj") &&

     

       11
       +
           (url.hostname.endsWith("discord.com") || url.hostname.endsWith("discordapp.com"))

     

       12
       +
         ) {

     

       13
       +
           console.log("Enabling block ruleset");

     

       14
        
           await chrome.declarativeNetRequest.updateEnabledRulesets({

     

       15
        
             enableRulesetIds: ["modifyResponseHeaders", "blockLoading"]

     

       16
        
           });

     

       0
        
       
     

       0
        
       
     

       17
        
         }

     

       18
        
       });

     

       19
        
       

     

       20
        
       chrome.webRequest.onBeforeRequest.addListener(

     

       21
        
         async (details) => {

     

       22
        
           if (details.tabId === -1) return;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       23
        
       

     

       24
       +
           const url = new URL(details.url);

     

       25
       +
           const hasUrl = scriptUrls.some((scriptUrl) => {

     

       26
       +
             return (

     

       27
       +
               details.url.includes(scriptUrl) &&

     

       28
       +
               !url.searchParams.has("inj") &&

     

       29
       +
               (url.hostname.endsWith("discord.com") || url.hostname.endsWith("discordapp.com"))

     

       30
       +
             );

     

       31
       +
           });

     

       32
       +
       

     

       33
       +
           if (hasUrl) blockedScripts.add(details.url);

     

       34
       +
       

     

       35
       +
           if (blockedScripts.size === scriptUrls.length) {

     

       36
       +
             const blockedScriptsCopy = Array.from(blockedScripts);

     

       37
       +
             blockedScripts.clear();

     

       38
        
       

     

       39
        
             console.log("Running moonlight script");

     

       40
        
             try {

     
···

       44
        
                 files: ["index.js"]

     

       45
        
               });

     

       46
        
             } catch (e) {

     

       47
       +
               console.error(e);

     

       48
        
             }

     

       49
        
       

     

       50
        
             console.log("Initializing moonlight");

     
···

       56
        
                   try {

     

       57
        
                     await window._moonlightBrowserInit();

     

       58
        
                   } catch (e) {

     

       59
       +
                     console.error(e);

     

       60
        
                   }

     

       61
        
                 }

     

       62
        
               });

     
···

       64
        
               console.log(e);

     

       65
        
             }

     

       66
        
       

     

       67
       +
             console.log("Disabling block ruleset");

     

       68
        
             try {

     

       0
        
       
     

       69
        
               await chrome.declarativeNetRequest.updateEnabledRulesets({

     

       70
        
                 disableRulesetIds: ["blockLoading"],

     

       71
        
                 enableRulesetIds: ["modifyResponseHeaders"]

     

       72
        
               });

     

       73
        
             } catch (e) {

     

       74
       +
               console.error(e);

     

       75
        
             }

     

       76
        
       

     

       77
        
             console.log("Readding scripts");

     
···

       79
        
               await chrome.scripting.executeScript({

     

       80
        
                 target: { tabId: details.tabId },

     

       81
        
                 world: "MAIN",

     

       82
       +
                 args: [blockedScriptsCopy],

     

       83
       +
                 func: async (blockedScripts) => {

     

       84
        
                   const scripts = [...document.querySelectorAll("script")].filter(

     

       85
       +
                     (script) => script.src && blockedScripts.some((url) => url.includes(script.src))

     

       86
        
                   );

     

       87
        
       

     

       88
       +
                   blockedScripts.reverse();

     

       89
       +
                   for (const url of blockedScripts) {

     

       90
       +
                     if (url.includes("/sentry.")) continue;

     

       0
        
       
     

       0
        
       
     

       91
        
       

     

       92
       +
                     const script = scripts.find((script) => url.includes(script.src));

     

       93
        
                     const newScript = document.createElement("script");

     

       94
       +
                     for (const attr of script.attributes) {

     

       95
       +
                       if (attr.name === "src") attr.value += "?inj";

     

       96
       +
                       newScript.setAttribute(attr.name, attr.value);

     

       97
        
                     }

     

       0
        
       
     

       98
        
                     script.remove();

     

       99
        
                     document.documentElement.appendChild(newScript);

     

       100
        
                   }

     

       101
        
                 }

     

       102
        
               });

     

       103
        
             } catch (e) {

     

       104
       +
               console.error(e);

     

       105
        
             }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       106
        
           }

     

       107
        
         },

     

       108
        
         {

     

       109
       +
           urls: ["*://*.discord.com/assets/*.js", "*://*.discordapp.com/assets/*.js"]

     

       110
        
         }

     

       111
        
       );

+12 -21

packages/core-extensions/src/moonbase/native.ts

···

       15
        
       

     

       16
        
       export const userAgent = `moonlight/${moonlightGlobal.version} (https://github.com/moonlight-mod/moonlight)`;

     

       17
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       18
        
       async function getStableRelease(): Promise<{

     

       19
        
         name: string;

     

       20
        
         assets: {

     
···

       24
        
       }> {

     

       25
        
         const req = await fetch(githubApiUrl, {

     

       26
        
           cache: "no-store",

     

       27
       -
           headers: {

     

       28
       -
             "User-Agent": userAgent

     

       29
       -
           }

     

       30
        
         });

     

       31
        
         return await req.json();

     

       32
        
       }

     
···

       43
        
               } else if (moonlightGlobal.branch === MoonlightBranch.NIGHTLY) {

     

       44
        
                 const req = await fetch(nightlyRefUrl, {

     

       45
        
                   cache: "no-store",

     

       46
       -
                   headers: {

     

       47
       -
                     "User-Agent": userAgent

     

       48
       -
                   }

     

       49
        
                 });

     

       50
        
                 const ref = (await req.text()).split("\n")[0];

     

       51
        
                 return ref !== moonlightGlobal.version ? ref : null;

     
···

       71
        
               logger.debug(`Downloading ${asset.browser_download_url}`);

     

       72
        
               const req = await fetch(asset.browser_download_url, {

     

       73
        
                 cache: "no-store",

     

       74
       -
                 headers: {

     

       75
       -
                   "User-Agent": userAgent

     

       76
       -
                 }

     

       77
        
               });

     

       78
        
       

     

       79
        
               return [await req.arrayBuffer(), json.name];

     
···

       83
        
               logger.debug(`Downloading ${nightlyZipUrl}`);

     

       84
        
               const zipReq = await fetch(nightlyZipUrl, {

     

       85
        
                 cache: "no-store",

     

       86
       -
                 headers: {

     

       87
       -
                   "User-Agent": userAgent

     

       88
       -
                 }

     

       89
        
               });

     

       90
        
       

     

       91
        
               const refReq = await fetch(nightlyRefUrl, {

     

       92
        
                 cache: "no-store",

     

       93
       -
                 headers: {

     

       94
       -
                   "User-Agent": userAgent

     

       95
       -
                 }

     

       96
        
               });

     

       97
        
               const ref = (await refReq.text()).split("\n")[0];

     

       98
        
       

     
···

       139
        
               try {

     

       140
        
                 const req = await fetch(repo, {

     

       141
        
                   cache: "no-store",

     

       142
       -
                   headers: {

     

       143
       -
                     "User-Agent": userAgent

     

       144
       -
                   }

     

       145
        
                 });

     

       146
        
                 const json = await req.json();

     

       147
        
                 ret[repo] = json;

     
···

       156
        
           async installExtension(manifest, url, repo) {

     

       157
        
             const req = await fetch(url, {

     

       158
        
               cache: "no-store",

     

       159
       -
               headers: {

     

       160
       -
                 "User-Agent": userAgent

     

       161
       -
               }

     

       162
        
             });

     

       163
        
       

     

       164
        
             const dir = moonlightGlobal.getExtensionDir(manifest.id);

···

       15
        
       

     

       16
        
       export const userAgent = `moonlight/${moonlightGlobal.version} (https://github.com/moonlight-mod/moonlight)`;

     

       17
        
       

     

       18
       +
       // User-Agent header causes trouble on Firefox

     

       19
       +
       const isBrowser = globalThis.moonlightNode != null && globalThis.moonlightNode.isBrowser;

     

       20
       +
       const sharedHeaders: Record<string, string> = {};

     

       21
       +
       if (!isBrowser) sharedHeaders["User-Agent"] = userAgent;

     

       22
       +
       

     

       23
        
       async function getStableRelease(): Promise<{

     

       24
        
         name: string;

     

       25
        
         assets: {

     
···

       29
        
       }> {

     

       30
        
         const req = await fetch(githubApiUrl, {

     

       31
        
           cache: "no-store",

     

       32
       +
           headers: sharedHeaders

     

       0
        
       
     

       0
        
       
     

       33
        
         });

     

       34
        
         return await req.json();

     

       35
        
       }

     
···

       46
        
               } else if (moonlightGlobal.branch === MoonlightBranch.NIGHTLY) {

     

       47
        
                 const req = await fetch(nightlyRefUrl, {

     

       48
        
                   cache: "no-store",

     

       49
       +
                   headers: sharedHeaders

     

       0
        
       
     

       0
        
       
     

       50
        
                 });

     

       51
        
                 const ref = (await req.text()).split("\n")[0];

     

       52
        
                 return ref !== moonlightGlobal.version ? ref : null;

     
···

       72
        
               logger.debug(`Downloading ${asset.browser_download_url}`);

     

       73
        
               const req = await fetch(asset.browser_download_url, {

     

       74
        
                 cache: "no-store",

     

       75
       +
                 headers: sharedHeaders

     

       0
        
       
     

       0
        
       
     

       76
        
               });

     

       77
        
       

     

       78
        
               return [await req.arrayBuffer(), json.name];

     
···

       82
        
               logger.debug(`Downloading ${nightlyZipUrl}`);

     

       83
        
               const zipReq = await fetch(nightlyZipUrl, {

     

       84
        
                 cache: "no-store",

     

       85
       +
                 headers: sharedHeaders

     

       0
        
       
     

       0
        
       
     

       86
        
               });

     

       87
        
       

     

       88
        
               const refReq = await fetch(nightlyRefUrl, {

     

       89
        
                 cache: "no-store",

     

       90
       +
                 headers: sharedHeaders

     

       0
        
       
     

       0
        
       
     

       91
        
               });

     

       92
        
               const ref = (await refReq.text()).split("\n")[0];

     

       93
        
       

     
···

       134
        
               try {

     

       135
        
                 const req = await fetch(repo, {

     

       136
        
                   cache: "no-store",

     

       137
       +
                   headers: sharedHeaders

     

       0
        
       
     

       0
        
       
     

       138
        
                 });

     

       139
        
                 const json = await req.json();

     

       140
        
                 ret[repo] = json;

     
···

       149
        
           async installExtension(manifest, url, repo) {

     

       150
        
             const req = await fetch(url, {

     

       151
        
               cache: "no-store",

     

       152
       +
               headers: sharedHeaders

     

       0
        
       
     

       0
        
       
     

       153
        
             });

     

       154
        
       

     

       155
        
             const dir = moonlightGlobal.getExtensionDir(manifest.id);