commit a8c4767eff746a7d09e3e8e428df8cb5d92c1cbe · notnite.com/moonlight

+5 -4

packages/core/src/extension/loader.ts

···

       10
       10
        
       import calculateDependencies from "../util/dependency";

     

       11
       11
        
       import { createEventEmitter } from "../util/event";

     

       12
       12
        
       import { registerStyles } from "../styles";

     

       13
       13
       +
       import { EventPayloads, EventType } from "@moonlight-mod/types/core/event";

     

       13
       14
        
       

     

       14
       15
        
       const logger = new Logger("core/extension/loader");

     

       15
       16
        
       

     
···

       159
       160
        
         extensions,

     

       160
       161
        
         dependencyGraph

     

       161
       162
        
       }: ProcessedExtensions) {

     

       162
       162
       -
         const eventEmitter = createEventEmitter();

     

       163
       163
       +
         const eventEmitter = createEventEmitter<EventType, EventPayloads>();

     

       163
       164
        
         const finished: Set<string> = new Set();

     

       164
       165
        
       

     

       165
       166
        
         logger.trace(

     
···

       181
       182
        
                 }

     

       182
       183
        
       

     

       183
       184
        
                 function done() {

     

       184
       184
       -
                   eventEmitter.removeEventListener("ext-ready", cb);

     

       185
       185
       +
                   eventEmitter.removeEventListener(EventType.ExtensionLoad, cb);

     

       185
       186
        
                   r();

     

       186
       187
        
                 }

     

       187
       188
        
       

     

       188
       188
       -
                 eventEmitter.addEventListener("ext-ready", cb);

     

       189
       189
       +
                 eventEmitter.addEventListener(EventType.ExtensionLoad, cb);

     

       189
       190
        
                 if (finished.has(dep)) done();

     

       190
       191
        
               })

     

       191
       192
        
           );

     
···

       201
       202
        
           await loadExt(ext);

     

       202
       203
        
       

     

       203
       204
        
           finished.add(ext.id);

     

       204
       204
       -
           eventEmitter.dispatchEvent("ext-ready", ext.id);

     

       205
       205
       +
           eventEmitter.dispatchEvent(EventType.ExtensionLoad, ext.id);

     

       205
       206
        
           logger.debug(`Loaded "${ext.id}"`);

     

       206
       207
        
         }

     

       207
       208

+57 -4

packages/core/src/patch.ts

···

       11
       11
        
       import Logger from "./util/logger";

     

       12
       12
        
       import calculateDependencies, { Dependency } from "./util/dependency";

     

       13
       13
        
       import WebpackRequire from "@moonlight-mod/types/discord/require";

     

       14
       14
       +
       import { EventType } from "@moonlight-mod/types/core/event";

     

       14
       15
        
       

     

       15
       16
        
       const logger = new Logger("core/patch");

     

       16
       17
        
       

     
···

       18
       19
        
       const patches: IdentifiedPatch[] = [];

     

       19
       20
        
       let webpackModules: Set<IdentifiedWebpackModule> = new Set();

     

       20
       21
        
       

     

       22
       22
       +
       const moduleLoadSubscriptions: Map<string, ((moduleId: string) => void)[]> =

     

       23
       23
       +
         new Map();

     

       24
       24
       +
       

     

       21
       25
        
       export function registerPatch(patch: IdentifiedPatch) {

     

       22
       26
        
         patches.push(patch);

     

       23
       27
        
         moonlight.unpatched.add(patch);

     
···

       27
       31
        
         webpackModules.add(wp);

     

       28
       32
        
         if (wp.dependencies?.length) {

     

       29
       33
        
           moonlight.pendingModules.add(wp);

     

       34
       34
       +
         }

     

       35
       35
       +
       }

     

       36
       36
       +
       

     

       37
       37
       +
       export function onModuleLoad(

     

       38
       38
       +
         module: string | string[],

     

       39
       39
       +
         callback: (moduleId: string) => void

     

       40
       40
       +
       ): void {

     

       41
       41
       +
         let moduleIds = module;

     

       42
       42
       +
       

     

       43
       43
       +
         if (typeof module === "string") {

     

       44
       44
       +
           moduleIds = [module];

     

       45
       45
       +
         }

     

       46
       46
       +
       

     

       47
       47
       +
         for (const moduleId of moduleIds) {

     

       48
       48
       +
           if (moduleLoadSubscriptions.has(moduleId)) {

     

       49
       49
       +
             moduleLoadSubscriptions.get(moduleId)?.push(callback);

     

       50
       50
       +
           } else {

     

       51
       51
       +
             moduleLoadSubscriptions.set(moduleId, [callback]);

     

       52
       52
       +
           }

     

       30
       53
        
         }

     

       31
       54
        
       }

     

       32
       55
        
       

     
···

       161
       184
        
             }

     

       162
       185
        
           }

     

       163
       186
        
       

     

       187
       187
       +
           // Dispatch module load event subscription

     

       188
       188
       +
           if (moduleLoadSubscriptions.has(id)) {

     

       189
       189
       +
             const loadCallbacks = moduleLoadSubscriptions.get(id)!;

     

       190
       190
       +
             for (const callback of loadCallbacks) {

     

       191
       191
       +
               try {

     

       192
       192
       +
                 callback(id);

     

       193
       193
       +
               } catch (e) {

     

       194
       194
       +
                 logger.error("Error in module load subscription: " + e);

     

       195
       195
       +
               }

     

       196
       196
       +
             }

     

       197
       197
       +
             moduleLoadSubscriptions.delete(id);

     

       198
       198
       +
           }

     

       199
       199
       +
       

     

       164
       200
        
           moduleCache[id] = moduleString;

     

       165
       201
        
         }

     

       166
       202
        
       }

     
···

       192
       228
        
             const deps = item.data?.dependencies ?? [];

     

       193
       229
        
             return (

     

       194
       230
        
               deps.filter(

     

       195
       195
       -
                 (dep) => !(dep instanceof RegExp || typeof dep === "string")

     

       231
       231
       +
                 (dep) =>

     

       232
       232
       +
                   !(

     

       233
       233
       +
                     dep instanceof RegExp ||

     

       234
       234
       +
                     typeof dep === "string" ||

     

       235
       235
       +
                     dep.ext === undefined

     

       236
       236
       +
                   )

     

       196
       237
        
               ) as ExplicitExtensionDependency[]

     

       197
       238
        
             ).map((x) => `${x.ext}_${x.id}`);

     

       198
       239
        
           }

     
···

       210
       251
        
         for (const [_modId, mod] of Object.entries(entry)) {

     

       211
       252
        
           const modStr = mod.toString();

     

       212
       253
        
           for (const wpModule of webpackModules) {

     

       213
       213
       -
             const id = wpModule.ext + "_" + wpModule.id;

     

       254
       254
       +
             const id = wpModule.ext ? wpModule.ext + "_" + wpModule.id : wpModule.id;

     

       214
       255
        
             if (wpModule.dependencies) {

     

       215
       256
        
               const deps = new Set(wpModule.dependencies);

     

       216
       257
        
       

     
···

       223
       264
        
                   } else if (dep instanceof RegExp) {

     

       224
       265
        
                     if (dep.test(modStr)) deps.delete(dep);

     

       225
       266
        
                   } else if (

     

       226
       226
       -
                     injectedWpModules.find(

     

       227
       227
       -
                       (x) => x.ext === dep.ext && x.id === dep.id

     

       267
       267
       +
                     injectedWpModules.find((x) =>

     

       268
       268
       +
                       wpModule.ext

     

       269
       269
       +
                         ? x.ext === dep.ext && x.id === dep.id

     

       270
       270
       +
                         : x.id === dep.id

     

       228
       271
        
                     )

     

       229
       272
        
                   ) {

     

       230
       273
        
                     deps.delete(dep);

     
···

       293
       336
        
             const realPush = jsonp.push;

     

       294
       337
        
             if (jsonp.push.__moonlight !== true) {

     

       295
       338
        
               jsonp.push = (items) => {

     

       339
       339
       +
                 moonlight.events.dispatchEvent(EventType.ChunkLoad, {

     

       340
       340
       +
                   chunkId: items[0],

     

       341
       341
       +
                   modules: items[1],

     

       342
       342
       +
                   require: items[2]

     

       343
       343
       +
                 });

     

       344
       344
       +
       

     

       296
       345
        
                 patchModules(items[1]);

     

       297
       346
        
       

     

       298
       347
        
                 try {

     
···

       335
       384
        
           set(modules: any) {

     

       336
       385
        
             const { stack } = new Error();

     

       337
       386
        
             if (stack!.includes("/assets/") && !Array.isArray(modules)) {

     

       387
       387
       +
               moonlight.events.dispatchEvent(EventType.ChunkLoad, {

     

       388
       388
       +
                 modules: modules

     

       389
       389
       +
               });

     

       338
       390
        
               patchModules(modules);

     

       391
       391
       +
       

     

       339
       392
        
               if (!window.webpackChunkdiscord_app)

     

       340
       393
        
                 window.webpackChunkdiscord_app = [];

     

       341
       394
        
               injectModules(modules);

+77 -45

packages/core/src/util/event.ts

···

       1
       1
       -
       export type MoonlightEventCallback = (data: string) => void;

     

       2
       2
       -
       

     

       3
       3
       -
       export interface MoonlightEventEmitter {

     

       4
       4
       -
         dispatchEvent: (id: string, data: string) => void;

     

       5
       5
       -
         addEventListener: (id: string, cb: MoonlightEventCallback) => void;

     

       6
       6
       -
         removeEventListener: (id: string, cb: MoonlightEventCallback) => void;

     

       7
       7
       -
       }

     

       1
       1
       +
       import { MoonlightEventEmitter } from "@moonlight-mod/types/core/event";

     

       8
       2
        
       

     

       9
       9
       -
       function nodeMethod(): MoonlightEventEmitter {

     

       3
       3
       +
       function nodeMethod<

     

       4
       4
       +
         EventId extends string = string,

     

       5
       5
       +
         EventData = Record<EventId, any>

     

       6
       6
       +
       >(): MoonlightEventEmitter<EventId, EventData> {

     

       10
       7
        
         const EventEmitter = require("events");

     

       11
       8
        
         const eventEmitter = new EventEmitter();

     

       12
       12
       -
         const listeners = new Map<MoonlightEventCallback, (...args: any[]) => void>();

     

       9
       9
       +
         const listeners = new Map<(data: EventData) => void, (e: Event) => void>();

     

       13
       10
        
       

     

       14
       11
        
         return {

     

       15
       15
       -
           dispatchEvent: (id: string, data: string) => {

     

       16
       16
       -
             eventEmitter.emit(id, data);

     

       12
       12
       +
           dispatchEvent: <Id extends keyof EventData>(

     

       13
       13
       +
             id: Id,

     

       14
       14
       +
             data: EventData[Id]

     

       15
       15
       +
           ) => {

     

       16
       16
       +
             eventEmitter.emit(id as string, data);

     

       17
       17
        
           },

     

       18
       18
        
       

     

       19
       19
       -
           addEventListener: (id: string, cb: (data: string) => void) => {

     

       20
       20
       -
             if (listeners.has(cb)) return;

     

       19
       19
       +
           addEventListener: <Id extends keyof EventData>(

     

       20
       20
       +
             id: Id,

     

       21
       21
       +
             cb: (data: EventData[Id]) => void

     

       22
       22
       +
           ) => {

     

       23
       23
       +
             const untyped = cb as (data: EventData) => void;

     

       24
       24
       +
             if (listeners.has(untyped)) return;

     

       21
       25
        
       

     

       22
       22
       -
             function listener(data: string) {

     

       23
       23
       -
               cb(data);

     

       26
       26
       +
             function listener(e: Event) {

     

       27
       27
       +
               const event = e as CustomEvent<string>;

     

       28
       28
       +
               cb(event as EventData[Id]);

     

       24
       29
        
             }

     

       25
       30
        
       

     

       26
       26
       -
             listeners.set(cb, listener);

     

       27
       27
       -
             eventEmitter.on(id, listener);

     

       31
       31
       +
             listeners.set(untyped, listener);

     

       32
       32
       +
             eventEmitter.on(id as string, listener);

     

       28
       33
        
           },

     

       29
       34
        
       

     

       30
       30
       -
           removeEventListener: (id: string, cb: (data: string) => void) => {

     

       31
       31
       -
             const listener = listeners.get(cb);

     

       35
       35
       +
           removeEventListener: <Id extends keyof EventData>(

     

       36
       36
       +
             id: Id,

     

       37
       37
       +
             cb: (data: EventData[Id]) => void

     

       38
       38
       +
           ) => {

     

       39
       39
       +
             const untyped = cb as (data: EventData) => void;

     

       40
       40
       +
             const listener = listeners.get(untyped);

     

       32
       41
        
             if (listener == null) return;

     

       33
       33
       -
             listeners.delete(cb);

     

       34
       34
       -
             eventEmitter.off(id, listener);

     

       42
       42
       +
             listeners.delete(untyped);

     

       43
       43
       +
             eventEmitter.off(id as string, listener);

     

       35
       44
        
           }

     

       36
       45
        
         };

     

       37
       46
        
       }

     

       38
       47
        
       

     

       39
       39
       -
       export function createEventEmitter(): MoonlightEventEmitter {

     

       40
       40
       -
         webPreload: {

     

       41
       41
       -
           const eventEmitter = new EventTarget();

     

       42
       42
       -
           const listeners = new Map<MoonlightEventCallback, (e: Event) => void>();

     

       48
       48
       +
       function webMethod<

     

       49
       49
       +
         EventId extends string = string,

     

       50
       50
       +
         EventData = Record<EventId, any>

     

       51
       51
       +
       >(): MoonlightEventEmitter<EventId, EventData> {

     

       52
       52
       +
         const eventEmitter = new EventTarget();

     

       53
       53
       +
         const listeners = new Map<(data: EventData) => void, (e: Event) => void>();

     

       43
       54
        
       

     

       44
       44
       -
           return {

     

       45
       45
       -
             dispatchEvent: (id: string, data: string) => {

     

       46
       46
       -
               eventEmitter.dispatchEvent(new CustomEvent(id, { detail: data }));

     

       47
       47
       -
             },

     

       55
       55
       +
         return {

     

       56
       56
       +
           dispatchEvent: <Id extends keyof EventData>(

     

       57
       57
       +
             id: Id,

     

       58
       58
       +
             data: EventData[Id]

     

       59
       59
       +
           ) => {

     

       60
       60
       +
             eventEmitter.dispatchEvent(

     

       61
       61
       +
               new CustomEvent(id as string, { detail: data })

     

       62
       62
       +
             );

     

       63
       63
       +
           },

     

       64
       64
       +
       

     

       65
       65
       +
           addEventListener: <Id extends keyof EventData>(

     

       66
       66
       +
             id: Id,

     

       67
       67
       +
             cb: (data: EventData[Id]) => void

     

       68
       68
       +
           ) => {

     

       69
       69
       +
             const untyped = cb as (data: EventData) => void;

     

       70
       70
       +
             if (listeners.has(untyped)) return;

     

       48
       71
        
       

     

       49
       49
       -
             addEventListener: (id: string, cb: (data: string) => void) => {

     

       50
       50
       -
               if (listeners.has(cb)) return;

     

       72
       72
       +
             function listener(e: Event) {

     

       73
       73
       +
               const event = e as CustomEvent<string>;

     

       74
       74
       +
               cb(event.detail as EventData[Id]);

     

       75
       75
       +
             }

     

       51
       76
        
       

     

       52
       52
       -
               function listener(e: Event) {

     

       53
       53
       -
                 const event = e as CustomEvent<string>;

     

       54
       54
       -
                 cb(event.detail);

     

       55
       55
       -
               }

     

       77
       77
       +
             listeners.set(untyped, listener);

     

       78
       78
       +
             eventEmitter.addEventListener(id as string, listener);

     

       79
       79
       +
           },

     

       56
       80
        
       

     

       57
       57
       -
               listeners.set(cb, listener);

     

       58
       58
       -
               eventEmitter.addEventListener(id, listener);

     

       59
       59
       -
             },

     

       81
       81
       +
           removeEventListener: <Id extends keyof EventData>(

     

       82
       82
       +
             id: Id,

     

       83
       83
       +
             cb: (data: EventData[Id]) => void

     

       84
       84
       +
           ) => {

     

       85
       85
       +
             const untyped = cb as (data: EventData) => void;

     

       86
       86
       +
             const listener = listeners.get(untyped);

     

       87
       87
       +
             if (listener == null) return;

     

       88
       88
       +
             listeners.delete(untyped);

     

       89
       89
       +
             eventEmitter.removeEventListener(id as string, listener);

     

       90
       90
       +
           }

     

       91
       91
       +
         };

     

       92
       92
       +
       }

     

       60
       93
        
       

     

       61
       61
       -
             removeEventListener: (id: string, cb: (data: string) => void) => {

     

       62
       62
       -
               const listener = listeners.get(cb);

     

       63
       63
       -
               if (listener == null) return;

     

       64
       64
       -
               listeners.delete(cb);

     

       65
       65
       -
               eventEmitter.removeEventListener(id, listener);

     

       66
       66
       -
             }

     

       67
       67
       -
           };

     

       94
       94
       +
       export function createEventEmitter<

     

       95
       95
       +
         EventId extends string = string,

     

       96
       96
       +
         EventData = Record<EventId, any>

     

       97
       97
       +
       >(): MoonlightEventEmitter<EventId, EventData> {

     

       98
       98
       +
         webPreload: {

     

       99
       99
       +
           return webMethod();

     

       68
       100
        
         }

     

       69
       101
        
       

     

       70
       102
        
         nodePreload: {

+33

packages/types/src/core/event.ts

···

       1
       1
       +
       import { WebpackModuleFunc, WebpackRequireType } from "../discord";

     

       2
       2
       +
       

     

       3
       3
       +
       export interface MoonlightEventEmitter<

     

       4
       4
       +
         EventId extends string = string,

     

       5
       5
       +
         EventData = Record<EventId, any>

     

       6
       6
       +
       > {

     

       7
       7
       +
         dispatchEvent: <Id extends keyof EventData>(

     

       8
       8
       +
           id: Id,

     

       9
       9
       +
           data: EventData[Id]

     

       10
       10
       +
         ) => void;

     

       11
       11
       +
         addEventListener: <Id extends keyof EventData>(

     

       12
       12
       +
           id: Id,

     

       13
       13
       +
           cb: (data: EventData[Id]) => void

     

       14
       14
       +
         ) => void;

     

       15
       15
       +
         removeEventListener: <Id extends keyof EventData>(

     

       16
       16
       +
           id: Id,

     

       17
       17
       +
           cb: (data: EventData[Id]) => void

     

       18
       18
       +
         ) => void;

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       export enum EventType {

     

       22
       22
       +
         ChunkLoad = "chunkLoad",

     

       23
       23
       +
         ExtensionLoad = "extensionLoad"

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       export type EventPayloads = {

     

       27
       27
       +
         [EventType.ChunkLoad]: {

     

       28
       28
       +
           chunkId?: number[];

     

       29
       29
       +
           modules: { [id: string]: WebpackModuleFunc };

     

       30
       30
       +
           require?: (require: WebpackRequireType) => any;

     

       31
       31
       +
         };

     

       32
       32
       +
         [EventType.ExtensionLoad]: string;

     

       33
       33
       +
       };

+1 -1

packages/types/src/extension.ts

···

       100
       100
        
       };

     

       101
       101
        
       

     

       102
       102
        
       export type ExplicitExtensionDependency = {

     

       103
       103
       -
         ext: string;

     

       103
       103
       +
         ext?: string;

     

       104
       104
        
         id: string;

     

       105
       105
        
       };

     

       106
       106

+10

packages/types/src/globals.ts

···

       7
       7
        
         ProcessedExtensions

     

       8
       8
        
       } from "./extension";

     

       9
       9
        
       import EventEmitter from "events";

     

       10
       10
       +
       import { EventPayloads, EventType, MoonlightEventEmitter } from "./core/event";

     

       10
       11
        
       

     

       11
       12
        
       export type MoonlightHost = {

     

       12
       13
        
         asarPath: string;

     
···

       39
       40
        
         unpatched: Set<IdentifiedPatch>;

     

       40
       41
        
         pendingModules: Set<IdentifiedWebpackModule>;

     

       41
       42
        
         enabledExtensions: Set<string>;

     

       43
       43
       +
         events: MoonlightEventEmitter<EventType, EventPayloads>;

     

       44
       44
       +
         patchingInternals: {

     

       45
       45
       +
           onModuleLoad: (

     

       46
       46
       +
             moduleId: string | string[],

     

       47
       47
       +
             callback: (moduleId: string) => void

     

       48
       48
       +
           ) => void;

     

       49
       49
       +
           registerPatch: (patch: IdentifiedPatch) => void;

     

       50
       50
       +
           registerWebpackModule: (module: IdentifiedWebpackModule) => void;

     

       51
       51
       +
         };

     

       42
       52
        
       

     

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

     

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

+2 -1

packages/web-preload/package.json

···

       2
       2
        
         "name": "@moonlight-mod/web-preload",

     

       3
       3
        
         "private": true,

     

       4
       4
        
         "dependencies": {

     

       5
       5
       -
           "@moonlight-mod/core": "workspace:*"

     

       5
       5
       +
           "@moonlight-mod/core": "workspace:*",

     

       6
       6
       +
           "@moonlight-mod/types": "workspace:*"

     

       6
       7
        
         }

     

       7
       8
        
       }

+14 -1

packages/web-preload/src/index.ts

···

       1
       1
        
       import { loadProcessedExtensions } from "@moonlight-mod/core/extension/loader";

     

       2
       2
       -
       import { installWebpackPatcher } from "@moonlight-mod/core/patch";

     

       2
       2
       +
       import {

     

       3
       3
       +
         installWebpackPatcher,

     

       4
       4
       +
         onModuleLoad,

     

       5
       5
       +
         registerPatch,

     

       6
       6
       +
         registerWebpackModule

     

       7
       7
       +
       } from "@moonlight-mod/core/patch";

     

       3
       8
        
       import { installStyles } from "@moonlight-mod/core/styles";

     

       4
       9
        
       import Logger from "@moonlight-mod/core/util/logger";

     

       10
       10
       +
       import { createEventEmitter } from "@moonlight-mod/core/util/event";

     

       11
       11
       +
       import { EventPayloads, EventType } from "@moonlight-mod/types/core/event";

     

       5
       12
        
       

     

       6
       13
        
       (async () => {

     

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

     
···

       10
       17
        
           unpatched: new Set(),

     

       11
       18
        
           pendingModules: new Set(),

     

       12
       19
        
           enabledExtensions: new Set(),

     

       20
       20
       +
           events: createEventEmitter<EventType, EventPayloads>(),

     

       21
       21
       +
           patchingInternals: {

     

       22
       22
       +
             onModuleLoad,

     

       23
       23
       +
             registerPatch,

     

       24
       24
       +
             registerWebpackModule

     

       25
       25
       +
           },

     

       13
       26
        
       

     

       14
       27
        
           getConfig: moonlightNode.getConfig.bind(moonlightNode),

     

       15
       28
        
           getConfigOption: moonlightNode.getConfigOption.bind(moonlightNode),

+13 -5

pnpm-lock.yaml

···

       10
       10
        
           devDependencies:

     

       11
       11
        
             '@typescript-eslint/eslint-plugin':

     

       12
       12
        
               specifier: ^6.13.2

     

       13
       13
       -
               version: 6.13.2(@typescript-eslint/parser@6.13.2)(eslint@8.55.0)(typescript@5.3.2)

     

       13
       13
       +
               version: 6.13.2(@typescript-eslint/parser@6.13.2(eslint@8.55.0)(typescript@5.3.2))(eslint@8.55.0)(typescript@5.3.2)

     

       14
       14
        
             '@typescript-eslint/parser':

     

       15
       15
        
               specifier: ^6.13.2

     

       16
       16
        
               version: 6.13.2(eslint@8.55.0)(typescript@5.3.2)

     
···

       28
       28
        
               version: 9.1.0(eslint@8.55.0)

     

       29
       29
        
             eslint-plugin-prettier:

     

       30
       30
        
               specifier: ^5.0.1

     

       31
       31
       -
               version: 5.0.1(eslint-config-prettier@9.1.0)(eslint@8.55.0)(prettier@3.1.0)

     

       31
       31
       +
               version: 5.0.1(eslint-config-prettier@9.1.0(eslint@8.55.0))(eslint@8.55.0)(prettier@3.1.0)

     

       32
       32
        
             eslint-plugin-react:

     

       33
       33
        
               specifier: ^7.33.2

     

       34
       34
        
               version: 7.33.2(eslint@8.55.0)

     
···

       95
       95
        
             '@moonlight-mod/core':

     

       96
       96
        
               specifier: workspace:*

     

       97
       97
        
               version: link:../core

     

       98
       98
       +
             '@moonlight-mod/types':

     

       99
       99
       +
               specifier: workspace:*

     

       100
       100
       +
               version: link:../types

     

       98
       101
        
       

     

       99
       102
        
       packages:

     

       100
       103
        
       

     
···

       1456
       1459
        
       

     

       1457
       1460
        
         '@types/semver@7.5.6': {}

     

       1458
       1461
        
       

     

       1459
       1459
       -
         '@typescript-eslint/eslint-plugin@6.13.2(@typescript-eslint/parser@6.13.2)(eslint@8.55.0)(typescript@5.3.2)':

     

       1462
       1462
       +
         '@typescript-eslint/eslint-plugin@6.13.2(@typescript-eslint/parser@6.13.2(eslint@8.55.0)(typescript@5.3.2))(eslint@8.55.0)(typescript@5.3.2)':

     

       1460
       1463
        
           dependencies:

     

       1461
       1464
        
             '@eslint-community/regexpp': 4.10.0

     

       1462
       1465
        
             '@typescript-eslint/parser': 6.13.2(eslint@8.55.0)(typescript@5.3.2)

     
···

       1471
       1474
        
             natural-compare: 1.4.0

     

       1472
       1475
        
             semver: 7.5.4

     

       1473
       1476
        
             ts-api-utils: 1.0.3(typescript@5.3.2)

     

       1477
       1477
       +
           optionalDependencies:

     

       1474
       1478
        
             typescript: 5.3.2

     

       1475
       1479
        
           transitivePeerDependencies:

     

       1476
       1480
        
             - supports-color

     
···

       1483
       1487
        
             '@typescript-eslint/visitor-keys': 6.13.2

     

       1484
       1488
        
             debug: 4.3.4

     

       1485
       1489
        
             eslint: 8.55.0

     

       1490
       1490
       +
           optionalDependencies:

     

       1486
       1491
        
             typescript: 5.3.2

     

       1487
       1492
        
           transitivePeerDependencies:

     

       1488
       1493
        
             - supports-color

     
···

       1499
       1504
        
             debug: 4.3.4

     

       1500
       1505
        
             eslint: 8.55.0

     

       1501
       1506
        
             ts-api-utils: 1.0.3(typescript@5.3.2)

     

       1507
       1507
       +
           optionalDependencies:

     

       1502
       1508
        
             typescript: 5.3.2

     

       1503
       1509
        
           transitivePeerDependencies:

     

       1504
       1510
        
             - supports-color

     
···

       1514
       1520
        
             is-glob: 4.0.3

     

       1515
       1521
        
             semver: 7.5.4

     

       1516
       1522
        
             ts-api-utils: 1.0.3(typescript@5.3.2)

     

       1523
       1523
       +
           optionalDependencies:

     

       1517
       1524
        
             typescript: 5.3.2

     

       1518
       1525
        
           transitivePeerDependencies:

     

       1519
       1526
        
             - supports-color

     
···

       1817
       1824
        
           dependencies:

     

       1818
       1825
        
             eslint: 8.55.0

     

       1819
       1826
        
       

     

       1820
       1820
       -
         eslint-plugin-prettier@5.0.1(eslint-config-prettier@9.1.0)(eslint@8.55.0)(prettier@3.1.0):

     

       1827
       1827
       +
         eslint-plugin-prettier@5.0.1(eslint-config-prettier@9.1.0(eslint@8.55.0))(eslint@8.55.0)(prettier@3.1.0):

     

       1821
       1828
        
           dependencies:

     

       1822
       1829
        
             eslint: 8.55.0

     

       1823
       1823
       -
             eslint-config-prettier: 9.1.0(eslint@8.55.0)

     

       1824
       1830
        
             prettier: 3.1.0

     

       1825
       1831
        
             prettier-linter-helpers: 1.0.0

     

       1826
       1832
        
             synckit: 0.8.6

     

       1833
       1833
       +
           optionalDependencies:

     

       1834
       1834
       +
             eslint-config-prettier: 9.1.0(eslint@8.55.0)

     

       1827
       1835
        
       

     

       1828
       1836
        
         eslint-plugin-react@7.33.2(eslint@8.55.0):

     

       1829
       1837
        
           dependencies: