···

       
5
       
 
       


     

       
6
       
 
       
const logger = moonlightNode.getLogger("disableSentry");

     

       
7
       
 
       


     

       
8
       
-
       
if (!ipcRenderer.sendSync(constants.ipcGetIsMoonlightDesktop)) {

     

       
9
       
-
       
  const preloadPath = ipcRenderer.sendSync(constants.ipcGetOldPreloadPath);

     

       
10
       
-
       
  try {

     

       
11
       
-
       
    const sentryPath = require.resolve(resolve(preloadPath, "..", "node_modules", "@sentry", "electron"));

     

       
12
       
-
       
    require.cache[sentryPath] = new Module(sentryPath, require.cache[require.resolve(preloadPath)]);

     

       
13
       
-
       
    require.cache[sentryPath]!.exports = {

     

       
14
       
-
       
      init: () => {},

     

       
15
       
-
       
      setTag: () => {},

     

       
16
       
-
       
      setUser: () => {},

     

       
17
       
-
       
      captureMessage: () => {}

     

       
18
       
-
       
    };

     

       
19
       
-
       
    logger.debug("Stubbed Sentry node side!");

     

       
20
       
-
       
  } catch (err) {

     

       
21
       
-
       
    logger.error("Failed to stub Sentry:", err);

     

       
22
       
-
       
  }

     

       
23
       
 
       
}

     

···

       
5
       
 
       


     

       
6
       
 
       
const logger = moonlightNode.getLogger("disableSentry");

     

       
7
       
 
       


     

       
8
       
+
       
const preloadPath = ipcRenderer.sendSync(constants.ipcGetOldPreloadPath);

     

       
9
       
+
       
try {

     

       
10
       
+
       
  const sentryPath = require.resolve(resolve(preloadPath, "..", "node_modules", "@sentry", "electron"));

     

       
11
       
+
       
  require.cache[sentryPath] = new Module(sentryPath, require.cache[require.resolve(preloadPath)]);

     

       
12
       
+
       
  require.cache[sentryPath]!.exports = {

     

       
13
       
+
       
    init: () => {},

     

       
14
       
+
       
    setTag: () => {},

     

       
15
       
+
       
    setUser: () => {},

     

       
16
       
+
       
    captureMessage: () => {}

     

       
17
       
+
       
  };

     

       
18
       
+
       
  logger.debug("Stubbed Sentry node side!");

     

       
19
       
+
       
} catch (err) {

     

       
20
       
+
       
  logger.error("Failed to stub Sentry:", err);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
21
       
 
       
}

     

···

       
6
       
 
       
} from "electron";

     

       
7
       
 
       
import Module from "node:module";

     

       
8
       
 
       
import { constants, MoonlightBranch } from "@moonlight-mod/types";

     

       
9
       
-
       
import { readConfig } from "@moonlight-mod/core/config";

     

       
10
       
 
       
import { getExtensions } from "@moonlight-mod/core/extension";

     

       
11
       
 
       
import Logger, { initLogger } from "@moonlight-mod/core/util/logger";

     

       
12
       
 
       
import { loadExtensions, loadProcessedExtensions } from "@moonlight-mod/core/extension/loader";

     

       
13
       
 
       
import EventEmitter from "node:events";

     

       
14
       
-
       
import { join, resolve } from "node:path";

     

       
15
       
 
       
import persist from "@moonlight-mod/core/persist";

     

       
16
       
 
       
import createFS from "@moonlight-mod/core/fs";

     

       
0
       
 
       

     

       
0
       
 
       

     

       
17
       
 
       


     

       
18
       
 
       
const logger = new Logger("injector");

     

       
19
       
 
       


     

       
20
       
 
       
let oldPreloadPath: string | undefined;

     

       
21
       
 
       
let corsAllow: string[] = [];

     

       
22
       
 
       
let blockedUrls: RegExp[] = [];

     

       
23
       
-
       
let isMoonlightDesktop = false;

     

       
24
       
-
       
let hasOpenAsar = false;

     

       
25
       
-
       
let openAsarConfigPreload: string | undefined;

     

       
26
       
 
       


     

       
27
       
 
       
const scriptUrls = ["web.", "sentry."];

     

       
28
       
 
       
const blockedScripts = new Set<string>();

     
···

       
34
       
 
       
ipcMain.on(constants.ipcGetAppData, (e) => {

     

       
35
       
 
       
  e.returnValue = app.getPath("appData");

     

       
36
       
 
       
});

     

       
37
       
-
       
ipcMain.on(constants.ipcGetIsMoonlightDesktop, (e) => {

     

       
38
       
-
       
  e.returnValue = isMoonlightDesktop;

     

       
39
       
 
       
});

     

       
40
       
 
       
ipcMain.handle(constants.ipcMessageBox, (_, opts) => {

     

       
41
       
 
       
  electron.dialog.showMessageBoxSync(opts);

     
···

       
114
       
 
       
  headers[csp] = [stringified];

     

       
115
       
 
       
}

     

       
116
       
 
       


     

       
117
       
-
       
function removeOpenAsarEventIfPresent(eventHandler: (...args: any[]) => void) {

     

       
118
       
-
       
  const code = eventHandler.toString();

     

       
119
       
-
       
  if (code.indexOf("bw.webContents.on('dom-ready'") > -1) {

     

       
120
       
-
       
    electron.app.off("browser-window-created", eventHandler);

     

       
121
       
-
       
  }

     

       
122
       
-
       
}

     

       
123
       
-
       


     

       
124
       
 
       
class BrowserWindow extends ElectronBrowserWindow {

     

       
125
       
 
       
  constructor(opts: BrowserWindowConstructorOptions) {

     

       
126
       
 
       
    const isMainWindow = opts.webPreferences!.preload!.indexOf("discord_desktop_core") > -1;

     
···

       
185
       
 
       
      // this is needed because multiple webRequest handlers cannot be registered at once

     

       
186
       
 
       
      cb({ cancel: blockedUrls.some((u) => u.test(details.url)) });

     

       
187
       
 
       
    });

     

       
188
       
-
       


     

       
189
       
-
       
    if (hasOpenAsar) {

     

       
190
       
-
       
      // Remove DOM injections

     

       
191
       
-
       
      // Settings can still be opened via:

     

       
192
       
-
       
      // `DiscordNative.ipc.send("DISCORD_UPDATED_QUOTES","o")`

     

       
193
       
-
       
      // @ts-expect-error Electron internals

     

       
194
       
-
       
      const events = electron.app._events["browser-window-created"];

     

       
195
       
-
       
      if (Array.isArray(events)) {

     

       
196
       
-
       
        for (const event of events) {

     

       
197
       
-
       
          removeOpenAsarEventIfPresent(event);

     

       
198
       
-
       
        }

     

       
199
       
-
       
      } else if (events != null) {

     

       
200
       
-
       
        removeOpenAsarEventIfPresent(events);

     

       
201
       
-
       
      }

     

       
202
       
-
       


     

       
203
       
-
       
      // Config screen fails to context bridge properly

     

       
204
       
-
       
      // Less than ideal, but better than disabling it everywhere

     

       
205
       
-
       
      if (opts.webPreferences!.preload === openAsarConfigPreload) {

     

       
206
       
-
       
        opts.webPreferences!.sandbox = false;

     

       
207
       
-
       
      }

     

       
208
       
-
       
    }

     

       
209
       
 
       
  }

     

       
210
       
 
       
}

     

       
211
       
 
       


     
···

       
226
       
 
       
  writable: false

     

       
227
       
 
       
});

     

       
228
       
 
       


     

       
229
       
-
       
export async function inject(asarPath: string) {

     

       
230
       
-
       
  isMoonlightDesktop = asarPath === "moonlightDesktop";

     

       
0
       
 
       

     

       
0
       
 
       

     

       
231
       
 
       
  global.moonlightNodeSandboxed = {

     

       
232
       
 
       
    fs: createFS(),

     

       
233
       
 
       
    // These aren't supposed to be used from host

     

       
234
       
-
       
    addCors(url) {},

     

       
235
       
-
       
    addBlocked(url) {}

     

       
236
       
 
       
  };

     

       
237
       
 
       


     

       
238
       
 
       
  try {

     

       
239
       
-
       
    const config = await readConfig();

     

       
240
       
 
       
    initLogger(config);

     

       
241
       
 
       
    const extensions = await getExtensions();

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
242
       
 
       


     

       
243
       
 
       
    // Duplicated in node-preload... oops

     

       
244
       
 
       
    function getConfig(ext: string) {

     
···

       
248
       
 
       
    }

     

       
249
       
 
       


     

       
250
       
 
       
    global.moonlightHost = {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
251
       
 
       
      asarPath,

     

       
252
       
-
       
      config,

     

       
253
       
 
       
      events: new EventEmitter(),

     

       
254
       
-
       
      extensions,

     

       
255
       
-
       
      processedExtensions: {

     

       
256
       
-
       
        extensions: [],

     

       
257
       
-
       
        dependencyGraph: new Map()

     

       
258
       
-
       
      },

     

       
259
       
 
       


     

       
260
       
 
       
      version: MOONLIGHT_VERSION,

     

       
261
       
 
       
      branch: MOONLIGHT_BRANCH as MoonlightBranch,

     

       
262
       
 
       


     

       
263
       
 
       
      getConfig,

     

       
264
       
-
       
      getConfigOption: <T>(ext: string, name: string) => {

     

       
265
       
-
       
        const config = getConfig(ext);

     

       
266
       
-
       
        if (config == null) return undefined;

     

       
267
       
-
       
        const option = config[name];

     

       
268
       
-
       
        if (option == null) return undefined;

     

       
269
       
-
       
        return option as T;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
270
       
 
       
      },

     

       
271
       
-
       
      getLogger: (id: string) => {

     

       
0
       
 
       

     

       
272
       
 
       
        return new Logger(id);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
273
       
 
       
      }

     

       
274
       
 
       
    };

     

       
275
       
 
       


     

       
276
       
-
       
    // Check if we're running with OpenAsar

     

       
277
       
-
       
    try {

     

       
278
       
-
       
      require.resolve(join(asarPath, "updater", "updater.js"));

     

       
279
       
-
       
      hasOpenAsar = true;

     

       
280
       
-
       
      openAsarConfigPreload = resolve(asarPath, "config", "preload.js");

     

       
281
       
-
       
      // eslint-disable-next-line no-empty

     

       
282
       
-
       
    } catch {}

     

       
283
       
-
       


     

       
284
       
-
       
    if (hasOpenAsar) {

     

       
285
       
-
       
      // Disable command line switch injection

     

       
286
       
-
       
      // I personally think that the command line switches should be vetted by

     

       
287
       
-
       
      // the user and not just "trust that these are sane defaults that work

     

       
288
       
-
       
      // always". I'm not hating on Ducko or anything, I'm just opinionated.

     

       
289
       
-
       
      // Someone can always make a command line modifier plugin, thats the point

     

       
290
       
-
       
      // of having host modules.

     

       
291
       
-
       
      try {

     

       
292
       
-
       
        const cmdSwitchesPath = require.resolve(join(asarPath, "cmdSwitches.js"));

     

       
293
       
-
       
        require.cache[cmdSwitchesPath] = new Module(cmdSwitchesPath, require.cache[require.resolve(asarPath)]);

     

       
294
       
-
       
        require.cache[cmdSwitchesPath]!.exports = () => {};

     

       
295
       
-
       
      } catch (error) {

     

       
296
       
-
       
        logger.error("Failed to disable OpenAsar's command line flags:", error);

     

       
297
       
-
       
      }

     

       
298
       
-
       
    }

     

       
299
       
-
       


     

       
300
       
 
       
    patchElectron();

     

       
301
       
 
       


     

       
302
       
-
       
    global.moonlightHost.processedExtensions = await loadExtensions(extensions);

     

       
303
       
 
       
    await loadProcessedExtensions(global.moonlightHost.processedExtensions);

     

       
304
       
 
       
  } catch (error) {

     

       
305
       
 
       
    logger.error("Failed to inject:", error);

     

       
306
       
 
       
  }

     

       
307
       
 
       


     

       
308
       
-
       
  if (isMoonlightDesktop) return;

     

       
309
       
-
       


     

       
310
       
-
       
  if (!hasOpenAsar && !isMoonlightDesktop) {

     

       
311
       
 
       
    persist(asarPath);

     

       
312
       
 
       
  }

     

       
313
       
 
       


     

       
314
       
-
       
  // Need to do this instead of require() or it breaks require.main

     

       
315
       
-
       
  // @ts-expect-error Module internals

     

       
316
       
-
       
  Module._load(asarPath, Module, true);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
317
       
 
       
}

     

       
318
       
 
       


     

       
319
       
 
       
function patchElectron() {

     

···

       
6
       
 
       
} from "electron";

     

       
7
       
 
       
import Module from "node:module";

     

       
8
       
 
       
import { constants, MoonlightBranch } from "@moonlight-mod/types";

     

       
9
       
+
       
import { readConfig, writeConfig } from "@moonlight-mod/core/config";

     

       
10
       
 
       
import { getExtensions } from "@moonlight-mod/core/extension";

     

       
11
       
 
       
import Logger, { initLogger } from "@moonlight-mod/core/util/logger";

     

       
12
       
 
       
import { loadExtensions, loadProcessedExtensions } from "@moonlight-mod/core/extension/loader";

     

       
13
       
 
       
import EventEmitter from "node:events";

     

       
14
       
+
       
import path from "node:path";

     

       
15
       
 
       
import persist from "@moonlight-mod/core/persist";

     

       
16
       
 
       
import createFS from "@moonlight-mod/core/fs";

     

       
17
       
+
       
import { getConfigOption, getManifest, setConfigOption } from "@moonlight-mod/core/util/config";

     

       
18
       
+
       
import { getExtensionsPath, getMoonlightDir } from "@moonlight-mod/core/util/data";

     

       
19
       
 
       


     

       
20
       
 
       
const logger = new Logger("injector");

     

       
21
       
 
       


     

       
22
       
 
       
let oldPreloadPath: string | undefined;

     

       
23
       
 
       
let corsAllow: string[] = [];

     

       
24
       
 
       
let blockedUrls: RegExp[] = [];

     

       
25
       
+
       
let injectorConfig: InjectorConfig | undefined;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
26
       
 
       


     

       
27
       
 
       
const scriptUrls = ["web.", "sentry."];

     

       
28
       
 
       
const blockedScripts = new Set<string>();

     
···

       
34
       
 
       
ipcMain.on(constants.ipcGetAppData, (e) => {

     

       
35
       
 
       
  e.returnValue = app.getPath("appData");

     

       
36
       
 
       
});

     

       
37
       
+
       
ipcMain.on(constants.ipcGetInjectorConfig, (e) => {

     

       
38
       
+
       
  e.returnValue = injectorConfig;

     

       
39
       
 
       
});

     

       
40
       
 
       
ipcMain.handle(constants.ipcMessageBox, (_, opts) => {

     

       
41
       
 
       
  electron.dialog.showMessageBoxSync(opts);

     
···

       
114
       
 
       
  headers[csp] = [stringified];

     

       
115
       
 
       
}

     

       
116
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
117
       
 
       
class BrowserWindow extends ElectronBrowserWindow {

     

       
118
       
 
       
  constructor(opts: BrowserWindowConstructorOptions) {

     

       
119
       
 
       
    const isMainWindow = opts.webPreferences!.preload!.indexOf("discord_desktop_core") > -1;

     
···

       
178
       
 
       
      // this is needed because multiple webRequest handlers cannot be registered at once

     

       
179
       
 
       
      cb({ cancel: blockedUrls.some((u) => u.test(details.url)) });

     

       
180
       
 
       
    });

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
181
       
 
       
  }

     

       
182
       
 
       
}

     

       
183
       
 
       


     
···

       
198
       
 
       
  writable: false

     

       
199
       
 
       
});

     

       
200
       
 
       


     

       
201
       
+
       
type InjectorConfig = { disablePersist?: boolean; disableLoad?: boolean };

     

       
202
       
+
       
export async function inject(asarPath: string, _injectorConfig?: InjectorConfig) {

     

       
203
       
+
       
  injectorConfig = _injectorConfig;

     

       
204
       
+
       


     

       
205
       
 
       
  global.moonlightNodeSandboxed = {

     

       
206
       
 
       
    fs: createFS(),

     

       
207
       
 
       
    // These aren't supposed to be used from host

     

       
208
       
+
       
    addCors() {},

     

       
209
       
+
       
    addBlocked() {}

     

       
210
       
 
       
  };

     

       
211
       
 
       


     

       
212
       
 
       
  try {

     

       
213
       
+
       
    let config = await readConfig();

     

       
214
       
 
       
    initLogger(config);

     

       
215
       
 
       
    const extensions = await getExtensions();

     

       
216
       
+
       
    const processedExtensions = await loadExtensions(extensions);

     

       
217
       
+
       
    const moonlightDir = await getMoonlightDir();

     

       
218
       
+
       
    const extensionsPath = await getExtensionsPath();

     

       
219
       
 
       


     

       
220
       
 
       
    // Duplicated in node-preload... oops

     

       
221
       
 
       
    function getConfig(ext: string) {

     
···

       
225
       
 
       
    }

     

       
226
       
 
       


     

       
227
       
 
       
    global.moonlightHost = {

     

       
228
       
+
       
      get config() {

     

       
229
       
+
       
        return config;

     

       
230
       
+
       
      },

     

       
231
       
+
       
      extensions,

     

       
232
       
+
       
      processedExtensions,

     

       
233
       
 
       
      asarPath,

     

       
0
       
 
       

     

       
234
       
 
       
      events: new EventEmitter(),

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
235
       
 
       


     

       
236
       
 
       
      version: MOONLIGHT_VERSION,

     

       
237
       
 
       
      branch: MOONLIGHT_BRANCH as MoonlightBranch,

     

       
238
       
 
       


     

       
239
       
 
       
      getConfig,

     

       
240
       
+
       
      getConfigOption(ext, name) {

     

       
241
       
+
       
        const manifest = getManifest(extensions, ext);

     

       
242
       
+
       
        return getConfigOption(ext, name, config, manifest?.settings);

     

       
243
       
+
       
      },

     

       
244
       
+
       
      setConfigOption(ext, name, value) {

     

       
245
       
+
       
        setConfigOption(config, ext, name, value);

     

       
246
       
+
       
        this.writeConfig(config);

     

       
247
       
+
       
      },

     

       
248
       
+
       
      async writeConfig(newConfig) {

     

       
249
       
+
       
        await writeConfig(newConfig);

     

       
250
       
+
       
        config = newConfig;

     

       
251
       
 
       
      },

     

       
252
       
+
       


     

       
253
       
+
       
      getLogger(id) {

     

       
254
       
 
       
        return new Logger(id);

     

       
255
       
+
       
      },

     

       
256
       
+
       
      getMoonlightDir() {

     

       
257
       
+
       
        return moonlightDir;

     

       
258
       
+
       
      },

     

       
259
       
+
       
      getExtensionDir: (ext: string) => {

     

       
260
       
+
       
        return path.join(extensionsPath, ext);

     

       
261
       
 
       
      }

     

       
262
       
 
       
    };

     

       
263
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
264
       
 
       
    patchElectron();

     

       
265
       
 
       


     

       
0
       
 
       

     

       
266
       
 
       
    await loadProcessedExtensions(global.moonlightHost.processedExtensions);

     

       
267
       
 
       
  } catch (error) {

     

       
268
       
 
       
    logger.error("Failed to inject:", error);

     

       
269
       
 
       
  }

     

       
270
       
 
       


     

       
271
       
+
       
  if (injectorConfig?.disablePersist !== true) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
272
       
 
       
    persist(asarPath);

     

       
273
       
 
       
  }

     

       
274
       
 
       


     

       
275
       
+
       
  if (injectorConfig?.disableLoad !== true) {

     

       
276
       
+
       
    // Need to do this instead of require() or it breaks require.main

     

       
277
       
+
       
    // @ts-expect-error Module internals

     

       
278
       
+
       
    Module._load(asarPath, Module, true);

     

       
279
       
+
       
  }

     

       
280
       
 
       
}

     

       
281
       
 
       


     

       
282
       
 
       
function patchElectron() {

     

···

       
66
       
 
       
      setConfigOption(config, ext, name, value);

     

       
67
       
 
       
      this.writeConfig(config);

     

       
68
       
 
       
    },

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
69
       
 
       


     

       
70
       
 
       
    getNatives: (ext: string) => global.moonlightNode.nativesCache[ext],

     

       
71
       
 
       
    getLogger: (id: string) => {

     

       
72
       
 
       
      return new Logger(id);

     

       
73
       
 
       
    },

     

       
74
       
-
       


     

       
75
       
 
       
    getMoonlightDir() {

     

       
76
       
 
       
      return moonlightDir;

     

       
77
       
 
       
    },

     

       
78
       
 
       
    getExtensionDir: (ext: string) => {

     

       
79
       
 
       
      return path.join(extensionsPath, ext);

     

       
80
       
-
       
    },

     

       
81
       
-
       
    async writeConfig(newConfig) {

     

       
82
       
-
       
      await writeConfig(newConfig);

     

       
83
       
-
       
      config = newConfig;

     

       
84
       
 
       
    }

     

       
85
       
 
       
  };

     

       
86
       
 
       


     

···

       
66
       
 
       
      setConfigOption(config, ext, name, value);

     

       
67
       
 
       
      this.writeConfig(config);

     

       
68
       
 
       
    },

     

       
69
       
+
       
    async writeConfig(newConfig) {

     

       
70
       
+
       
      await writeConfig(newConfig);

     

       
71
       
+
       
      config = newConfig;

     

       
72
       
+
       
    },

     

       
73
       
 
       


     

       
74
       
 
       
    getNatives: (ext: string) => global.moonlightNode.nativesCache[ext],

     

       
75
       
 
       
    getLogger: (id: string) => {

     

       
76
       
 
       
      return new Logger(id);

     

       
77
       
 
       
    },

     

       
0
       
 
       

     

       
78
       
 
       
    getMoonlightDir() {

     

       
79
       
 
       
      return moonlightDir;

     

       
80
       
 
       
    },

     

       
81
       
 
       
    getExtensionDir: (ext: string) => {

     

       
82
       
 
       
      return path.join(extensionsPath, ext);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
83
       
 
       
    }

     

       
84
       
 
       
  };

     

       
85
       
 
       


     

···

       
8
       
 
       
export const ipcGetOldPreloadPath = "_moonlight_getOldPreloadPath";

     

       
9
       
 
       


     

       
10
       
 
       
export const ipcGetAppData = "_moonlight_getAppData";

     

       
11
       
-
       
export const ipcGetIsMoonlightDesktop = "_moonlight_getIsMoonlightDesktop";

     

       
12
       
 
       
export const ipcMessageBox = "_moonlight_messageBox";

     

       
13
       
 
       
export const ipcSetCorsList = "_moonlight_setCorsList";

     

       
14
       
 
       
export const ipcSetBlockedList = "_moonlight_setBlockedList";

     

···

       
8
       
 
       
export const ipcGetOldPreloadPath = "_moonlight_getOldPreloadPath";

     

       
9
       
 
       


     

       
10
       
 
       
export const ipcGetAppData = "_moonlight_getAppData";

     

       
11
       
+
       
export const ipcGetInjectorConfig = "_moonlight_getInjectorConfig";

     

       
12
       
 
       
export const ipcMessageBox = "_moonlight_messageBox";

     

       
13
       
 
       
export const ipcSetCorsList = "_moonlight_setCorsList";

     

       
14
       
 
       
export const ipcSetBlockedList = "_moonlight_setBlockedList";

     

···

       
8
       
 
       
import { MoonlightFS } from "./fs";

     

       
9
       
 
       


     

       
10
       
 
       
export type MoonlightHost = {

     

       
11
       
-
       
  asarPath: string;

     

       
12
       
 
       
  config: Config;

     

       
13
       
-
       
  events: EventEmitter;

     

       
14
       
 
       
  extensions: DetectedExtension[];

     

       
15
       
 
       
  processedExtensions: ProcessedExtensions;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
16
       
 
       


     

       
17
       
 
       
  version: string;

     

       
18
       
 
       
  branch: MoonlightBranch;

     

       
19
       
 
       


     

       
20
       
 
       
  getConfig: (ext: string) => ConfigExtension["config"];

     

       
21
       
 
       
  getConfigOption: <T>(ext: string, name: string) => T | undefined;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
22
       
 
       
  getLogger: (id: string) => Logger;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
23
       
 
       
};

     

       
24
       
 
       


     

       
25
       
 
       
export type MoonlightNode = {

     
···

       
35
       
 
       
  getConfig: (ext: string) => ConfigExtension["config"];

     

       
36
       
 
       
  getConfigOption: <T>(ext: string, name: string) => T | undefined;

     

       
37
       
 
       
  setConfigOption: <T>(ext: string, name: string, value: T) => void;

     

       
0
       
 
       

     

       
38
       
 
       


     

       
39
       
 
       
  getNatives: (ext: string) => any | undefined;

     

       
40
       
 
       
  getLogger: (id: string) => Logger;

     

       
41
       
-
       


     

       
42
       
 
       
  getMoonlightDir: () => string;

     

       
43
       
 
       
  getExtensionDir: (ext: string) => string;

     

       
44
       
-
       
  writeConfig: (config: Config) => Promise<void>;

     

       
45
       
 
       
};

     

       
46
       
 
       


     

       
47
       
 
       
export type MoonlightNodeSandboxed = {

     
···

       
54
       
 
       
  unpatched: Set<IdentifiedPatch>;

     

       
55
       
 
       
  pendingModules: Set<IdentifiedWebpackModule>;

     

       
56
       
 
       
  enabledExtensions: Set<string>;

     

       
57
       
-
       
  apiLevel: number;

     

       
58
       
 
       
  events: MoonlightEventEmitter<EventType, EventPayloads>;

     

       
59
       
 
       
  patchingInternals: {

     

       
60
       
 
       
    onModuleLoad: (moduleId: string | string[], callback: (moduleId: string) => void) => void;

     
···

       
65
       
 
       


     

       
66
       
 
       
  version: string;

     

       
67
       
 
       
  branch: MoonlightBranch;

     

       
0
       
 
       

     

       
68
       
 
       


     

       
69
       
 
       
  // Re-exports for ease of use

     

       
70
       
 
       
  getConfig: MoonlightNode["getConfig"];

     

       
71
       
 
       
  getConfigOption: MoonlightNode["getConfigOption"];

     

       
72
       
 
       
  setConfigOption: MoonlightNode["setConfigOption"];

     

       
0
       
 
       

     

       
73
       
 
       


     

       
74
       
 
       
  getNatives: (ext: string) => any | undefined;

     

       
75
       
 
       
  getLogger: (id: string) => Logger;

     

       
0
       
 
       

     

       
76
       
 
       
  lunast: LunAST;

     

       
77
       
 
       
  moonmap: Moonmap;

     

       
78
       
 
       
};

     

···

       
8
       
 
       
import { MoonlightFS } from "./fs";

     

       
9
       
 
       


     

       
10
       
 
       
export type MoonlightHost = {

     

       
0
       
 
       

     

       
11
       
 
       
  config: Config;

     

       
0
       
 
       

     

       
12
       
 
       
  extensions: DetectedExtension[];

     

       
13
       
 
       
  processedExtensions: ProcessedExtensions;

     

       
14
       
+
       
  asarPath: string;

     

       
15
       
+
       
  events: EventEmitter;

     

       
16
       
 
       


     

       
17
       
 
       
  version: string;

     

       
18
       
 
       
  branch: MoonlightBranch;

     

       
19
       
 
       


     

       
20
       
 
       
  getConfig: (ext: string) => ConfigExtension["config"];

     

       
21
       
 
       
  getConfigOption: <T>(ext: string, name: string) => T | undefined;

     

       
22
       
+
       
  setConfigOption: <T>(ext: string, name: string, value: T) => void;

     

       
23
       
+
       
  writeConfig: (config: Config) => Promise<void>;

     

       
24
       
+
       


     

       
25
       
 
       
  getLogger: (id: string) => Logger;

     

       
26
       
+
       
  getMoonlightDir: () => string;

     

       
27
       
+
       
  getExtensionDir: (ext: string) => string;

     

       
28
       
 
       
};

     

       
29
       
 
       


     

       
30
       
 
       
export type MoonlightNode = {

     
···

       
40
       
 
       
  getConfig: (ext: string) => ConfigExtension["config"];

     

       
41
       
 
       
  getConfigOption: <T>(ext: string, name: string) => T | undefined;

     

       
42
       
 
       
  setConfigOption: <T>(ext: string, name: string, value: T) => void;

     

       
43
       
+
       
  writeConfig: (config: Config) => Promise<void>;

     

       
44
       
 
       


     

       
45
       
 
       
  getNatives: (ext: string) => any | undefined;

     

       
46
       
 
       
  getLogger: (id: string) => Logger;

     

       
0
       
 
       

     

       
47
       
 
       
  getMoonlightDir: () => string;

     

       
48
       
 
       
  getExtensionDir: (ext: string) => string;

     

       
0
       
 
       

     

       
49
       
 
       
};

     

       
50
       
 
       


     

       
51
       
 
       
export type MoonlightNodeSandboxed = {

     
···

       
58
       
 
       
  unpatched: Set<IdentifiedPatch>;

     

       
59
       
 
       
  pendingModules: Set<IdentifiedWebpackModule>;

     

       
60
       
 
       
  enabledExtensions: Set<string>;

     

       
0
       
 
       

     

       
61
       
 
       
  events: MoonlightEventEmitter<EventType, EventPayloads>;

     

       
62
       
 
       
  patchingInternals: {

     

       
63
       
 
       
    onModuleLoad: (moduleId: string | string[], callback: (moduleId: string) => void) => void;

     
···

       
68
       
 
       


     

       
69
       
 
       
  version: string;

     

       
70
       
 
       
  branch: MoonlightBranch;

     

       
71
       
+
       
  apiLevel: number;

     

       
72
       
 
       


     

       
73
       
 
       
  // Re-exports for ease of use

     

       
74
       
 
       
  getConfig: MoonlightNode["getConfig"];

     

       
75
       
 
       
  getConfigOption: MoonlightNode["getConfigOption"];

     

       
76
       
 
       
  setConfigOption: MoonlightNode["setConfigOption"];

     

       
77
       
+
       
  writeConfig: MoonlightNode["writeConfig"];

     

       
78
       
 
       


     

       
79
       
 
       
  getNatives: (ext: string) => any | undefined;

     

       
80
       
 
       
  getLogger: (id: string) => Logger;

     

       
81
       
+
       


     

       
82
       
 
       
  lunast: LunAST;

     

       
83
       
 
       
  moonmap: Moonmap;

     

       
84
       
 
       
};

     

···

       
15
       
 
       
  const logger = new Logger("web-preload");

     

       
16
       
 
       


     

       
17
       
 
       
  window.moonlight = {

     

       
18
       
-
       
    apiLevel: constants.apiLevel,

     

       
19
       
 
       
    unpatched: new Set(),

     

       
20
       
 
       
    pendingModules: new Set(),

     

       
21
       
 
       
    enabledExtensions: new Set(),

     

       
0
       
 
       

     

       
22
       
 
       
    events: createEventEmitter<EventType, EventPayloads>(),

     

       
23
       
 
       
    patchingInternals: {

     

       
24
       
 
       
      onModuleLoad,

     
···

       
29
       
 
       


     

       
30
       
 
       
    version: MOONLIGHT_VERSION,

     

       
31
       
 
       
    branch: MOONLIGHT_BRANCH as MoonlightBranch,

     

       
0
       
 
       

     

       
32
       
 
       


     

       
33
       
 
       
    getConfig: moonlightNode.getConfig.bind(moonlightNode),

     

       
34
       
 
       
    getConfigOption: moonlightNode.getConfigOption.bind(moonlightNode),

     

       
35
       
 
       
    setConfigOption: moonlightNode.setConfigOption.bind(moonlightNode),

     

       
0
       
 
       

     

       
36
       
 
       


     

       
37
       
 
       
    getNatives: moonlightNode.getNatives.bind(moonlightNode),

     

       
38
       
 
       
    getLogger(id) {

     

       
39
       
 
       
      return new Logger(id);

     

       
40
       
 
       
    },

     

       
0
       
 
       

     

       
41
       
 
       
    lunast: new LunAST(),

     

       
42
       
 
       
    moonmap: new Moonmap()

     

       
43
       
 
       
  };

     

···

       
15
       
 
       
  const logger = new Logger("web-preload");

     

       
16
       
 
       


     

       
17
       
 
       
  window.moonlight = {

     

       
0
       
 
       

     

       
18
       
 
       
    unpatched: new Set(),

     

       
19
       
 
       
    pendingModules: new Set(),

     

       
20
       
 
       
    enabledExtensions: new Set(),

     

       
21
       
+
       


     

       
22
       
 
       
    events: createEventEmitter<EventType, EventPayloads>(),

     

       
23
       
 
       
    patchingInternals: {

     

       
24
       
 
       
      onModuleLoad,

     
···

       
29
       
 
       


     

       
30
       
 
       
    version: MOONLIGHT_VERSION,

     

       
31
       
 
       
    branch: MOONLIGHT_BRANCH as MoonlightBranch,

     

       
32
       
+
       
    apiLevel: constants.apiLevel,

     

       
33
       
 
       


     

       
34
       
 
       
    getConfig: moonlightNode.getConfig.bind(moonlightNode),

     

       
35
       
 
       
    getConfigOption: moonlightNode.getConfigOption.bind(moonlightNode),

     

       
36
       
 
       
    setConfigOption: moonlightNode.setConfigOption.bind(moonlightNode),

     

       
37
       
+
       
    writeConfig: moonlightNode.writeConfig.bind(moonlightNode),

     

       
38
       
 
       


     

       
39
       
 
       
    getNatives: moonlightNode.getNatives.bind(moonlightNode),

     

       
40
       
 
       
    getLogger(id) {

     

       
41
       
 
       
      return new Logger(id);

     

       
42
       
 
       
    },

     

       
43
       
+
       


     

       
44
       
 
       
    lunast: new LunAST(),

     

       
45
       
 
       
    moonmap: new Moonmap()

     

       
46
       
 
       
  };