commit 41331b0319d550deb30944fc5ea8c10adb9abf61 · notnite.com/moonlight

+1 -1

.prettierignore

···

       1
       1
       -
       pnpm-lock.yml
     

       1
       1
       +
       pnpm-lock.yaml

+2 -1

packages/core/package.json

···

       6
       6
        
         },

     

       7
       7
        
         "dependencies": {

     

       8
       8
        
           "@moonlight-mod/types": "workspace:*",

     

       9
       9
       -
           "@moonlight-mod/lunast": "workspace:*"

     

       9
       9
       +
           "@moonlight-mod/lunast": "git+https://github.com/moonlight-mod/lunast.git",

     

       10
       10
       +
           "@moonlight-mod/moonmap": "git+https://github.com/moonlight-mod/moonmap.git"

     

       10
       11
        
         }

     

       11
       12
        
       }

+16 -12

packages/core/src/patch.ts

···

       78
       78
        
         for (const [id, func] of Object.entries(entry)) {

     

       79
       79
        
           if (!Object.hasOwn(moduleCache, id) && func.__moonlight !== true) {

     

       80
       80
        
             moduleCache[id] = func.toString().replace(/\n/g, "");

     

       81
       81
       +
             moonlight.moonmap.parseScript(id, moduleCache[id]);

     

       81
       82
        
           }

     

       82
       83
        
         }

     

       83
       84
        
       

     
···

       162
       163
        
             const parsed = moonlight.lunast.parseScript(id, moduleString);

     

       163
       164
        
             if (parsed != null) {

     

       164
       165
        
               for (const [parsedId, parsedScript] of Object.entries(parsed)) {

     

       165
       165
       -
                 // parseScript adds an extra ; for some reason

     

       166
       166
       -
                 const fixedScript = parsedScript

     

       167
       167
       -
                   .trimEnd()

     

       168
       168
       -
                   .substring(0, parsedScript.lastIndexOf(";"));

     

       169
       169
       -
       

     

       170
       170
       -
                 if (patchModule(parsedId, "lunast", fixedScript)) {

     

       171
       171
       -
                   moduleCache[parsedId] = fixedScript;

     

       166
       166
       +
                 if (patchModule(parsedId, "lunast", parsedScript)) {

     

       167
       167
       +
                   moduleCache[parsedId] = parsedScript;

     

       172
       168
        
                 }

     

       173
       169
        
               }

     

       174
       170
        
             }

     
···

       238
       234
        
         const entrypoints: string[] = [];

     

       239
       235
        
         let inject = false;

     

       240
       236
        
       

     

       237
       237
       +
         for (const [name, func] of Object.entries(

     

       238
       238
       +
           moonlight.moonmap.getWebpackModules("window.moonlight.moonmap")

     

       239
       239
       +
         )) {

     

       240
       240
       +
           modules[name] = func;

     

       241
       241
       +
           inject = true;

     

       242
       242
       +
         }

     

       243
       243
       +
       

     

       241
       244
        
         for (const [_modId, mod] of Object.entries(entry)) {

     

       242
       245
        
           const modStr = mod.toString();

     

       243
       246
        
           for (const wpModule of webpackModules) {

     
···

       300
       303
        
         interface Window {

     

       301
       304
        
           webpackChunkdiscord_app: WebpackJsonp;

     

       302
       305
        
         }

     

       306
       306
       +
       }

     

       307
       307
       +
       

     

       308
       308
       +
       function moduleSourceGetter(id: string) {

     

       309
       309
       +
         return moduleCache[id] ?? null;

     

       303
       310
        
       }

     

       304
       311
        
       

     

       305
       312
        
       /*

     
···

       313
       320
        
       export async function installWebpackPatcher() {

     

       314
       321
        
         await handleModuleDependencies();

     

       315
       322
        
       

     

       316
       316
       -
         moonlight.lunast.setModuleSourceGetter((id) => {

     

       317
       317
       -
           return moduleCache[id] ?? null;

     

       318
       318
       -
         });

     

       323
       323
       +
         moonlight.lunast.setModuleSourceGetter(moduleSourceGetter);

     

       324
       324
       +
         moonlight.moonmap.setModuleSourceGetter(moduleSourceGetter);

     

       319
       325
        
       

     

       320
       326
        
         let realWebpackJsonp: WebpackJsonp | null = null;

     

       321
       327
        
         Object.defineProperty(window, "webpackChunkdiscord_app", {

     
···

       375
       381
        
                 window.webpackChunkdiscord_app = [];

     

       376
       382
        
               injectModules(modules);

     

       377
       383
        
             }

     

       378
       378
       -
       

     

       379
       379
       -
             moonlight.lunast.setDefaultRequire(this);

     

       380
       384
        
       

     

       381
       385
        
             Object.defineProperty(this, "m", {

     

       382
       386
        
               value: modules,

-131

packages/lunast/README.md

···

       1
       1
       -
       # LunAST

     

       2
       2
       -
       

     

       3
       3
       -
       LunAST is an experimental in-development [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree)-based remapper and patcher for Webpack modules.

     

       4
       4
       -
       

     

       5
       5
       -
       ## Introduction

     

       6
       6
       -
       

     

       7
       7
       -
       Modern Webpack patching functions off of matching existing minified code (using a string or regular expression) and then replacing it. While this is an easy to use and powerful way of patching Webpack modules, there are many downsides:

     

       8
       8
       -
       

     

       9
       9
       -
       - Even the smallest change can break patches, which can require lots of maintenance, especially on large Discord bundler changes.

     

       10
       10
       -
       - Fetching exports from a Webpack module will sometimes result in minified export names. These exports must be manually remapped to human readable names by a library extension.

     

       11
       11
       -
       - Making complicated patches is extremely difficult and means your patch has more points of failure.

     

       12
       12
       -
       

     

       13
       13
       -
       To solve this, LunAST generates [the ESTree format](https://github.com/estree/estree) with a handful of libraries ([meriyah](https://github.com/meriyah/meriyah), [estree-toolkit](https://github.com/sarsamurmu/estree-toolkit), [astring](https://github.com/davidbonnet/astring)) on each Webpack module. This makes large-scale manipulation and mapping feasible, by allowing you to write code to detect what modules you want to find.

     

       14
       14
       -
       

     

       15
       15
       -
       ## Usage

     

       16
       16
       -
       

     

       17
       17
       -
       ### Embedding into your own code

     

       18
       18
       -
       

     

       19
       19
       -
       LunAST is not ready to be used in other projects just yet. In the future, LunAST will be a standalone library.

     

       20
       20
       -
       

     

       21
       21
       -
       ### Registering a processor

     

       22
       22
       -
       

     

       23
       23
       -
       LunAST functions off of "processors". Processors have a unique ID, an optional filter (string or regex) on what to parse, and a process function which receives the AST.

     

       24
       24
       -
       

     

       25
       25
       -
       The process function returns a boolean, which when true will unregister the processor. Once you have found what you're looking for, you can return true to skip parsing any other subsequent module, speeding up load times.

     

       26
       26
       -
       

     

       27
       27
       -
       LunAST includes some core processors, and extensions can register their own processors (citation needed).

     

       28
       28
       -
       

     

       29
       29
       -
       ```ts

     

       30
       30
       -
       register({

     

       31
       31
       -
         name: "UniqueIDForTheProcessorSystem",

     

       32
       32
       -
         find: "some string or regex to search for", // optional

     

       33
       33
       -
         priority: 0, // optional

     

       34
       34
       -
         process({ id, ast, lunast }) {

     

       35
       35
       -
           // do some stuff with the ast

     

       36
       36
       -
           return false; // return true to unregister

     

       37
       37
       -
         }

     

       38
       38
       -
       });

     

       39
       39
       -
       ```

     

       40
       40
       -
       

     

       41
       41
       -
       ### Mapping with LunAST

     

       42
       42
       -
       

     

       43
       43
       -
       LunAST can use proxies to remap minified export names to more human readable ones. Let's say that you determined the module ID and export name of a component you want in a module.

     

       44
       44
       -
       

     

       45
       45
       -
       First, you must define the type. A type contains a unique name and a list of fields. These fields contain the minified name and the human-readable name that can be used in code.

     

       46
       46
       -
       

     

       47
       47
       -
       Then, register the module, with the ID passed to you in the process function. Specify its type so the remapper knows what fields to remap. It is suggested to name the module and type with the same name.

     

       48
       48
       -
       

     

       49
       49
       -
       ```ts

     

       50
       50
       -
       process({ id, ast, lunast }) {

     

       51
       51
       -
         let exportName: string | null = null;

     

       52
       52
       -
       

     

       53
       53
       -
         // some code to discover the export name...

     

       54
       54
       -
       

     

       55
       55
       -
         if (exportName != null) {

     

       56
       56
       -
           lunast.addType({

     

       57
       57
       -
             name: "SomeModule",

     

       58
       58
       -
             fields: [

     

       59
       59
       -
               {

     

       60
       60
       -
                 name: "SomeComponent",

     

       61
       61
       -
                 unmapped: exportName

     

       62
       62
       -
               }

     

       63
       63
       -
             ]

     

       64
       64
       -
           });

     

       65
       65
       -
           lunast.addModule({

     

       66
       66
       -
             name: "SomeModule",

     

       67
       67
       -
             id,

     

       68
       68
       -
             type: "SomeModule"

     

       69
       69
       -
           });

     

       70
       70
       -
           return true;

     

       71
       71
       -
         }

     

       72
       72
       -
       

     

       73
       73
       -
         return false;

     

       74
       74
       -
       }

     

       75
       75
       -
       ```

     

       76
       76
       -
       

     

       77
       77
       -
       Then, you need to specify the type of the module in `types.ts`. Using the `import` statement in Webpack modules is not supported yet. Hopefully this step is automated in the future.

     

       78
       78
       -
       

     

       79
       79
       -
       After all this, fetch the remapped module and its remapped field:

     

       80
       80
       -
       

     

       81
       81
       -
       ```ts

     

       82
       82
       -
       moonlight.lunast.remap("SomeModule").SomeComponent

     

       83
       83
       -
       ```

     

       84
       84
       -
       

     

       85
       85
       -
       ### Patching with LunAST

     

       86
       86
       -
       

     

       87
       87
       -
       LunAST also enables you to modify the AST and then rebuild a module string from the modified AST. It is suggested you read the [estree-toolkit](https://estree-toolkit.netlify.app/welcome) documentation.

     

       88
       88
       -
       

     

       89
       89
       -
       You can use the `magicAST` function to turn some JavaScript code into another AST node, and then merge/replace the original AST.

     

       90
       90
       -
       

     

       91
       91
       -
       **After you modify the AST, call the markDirty function.** LunAST will not know to replace the module otherwise.

     

       92
       92
       -
       

     

       93
       93
       -
       ```ts

     

       94
       94
       -
       process({ ast, markDirty }) {

     

       95
       95
       -
         const node = /* do something with the AST */;

     

       96
       96
       -
         if (node != null) {

     

       97
       97
       -
           const replacement = magicAST("return 1 + 1");

     

       98
       98
       -
           node.replaceWith(replacement);

     

       99
       99
       -
           markDirty();

     

       100
       100
       -
           return true;

     

       101
       101
       -
         }

     

       102
       102
       -
       

     

       103
       103
       -
         return false;

     

       104
       104
       -
       }

     

       105
       105
       -
       ```

     

       106
       106
       -
       

     

       107
       107
       -
       ## FAQ

     

       108
       108
       -
       

     

       109
       109
       -
       ### How do you fetch the scripts to parse?

     

       110
       110
       -
       

     

       111
       111
       -
       Fetching the content of the `<script>` tags is impossible, and making a `fetch` request would result in different headers to what the client would normally send. We use `Function.prototype.toString()` and wrap the function in parentheses to ensure the anonymous function is valid JavaScript.

     

       112
       112
       -
       

     

       113
       113
       -
       ### Isn't this slow?

     

       114
       114
       -
       

     

       115
       115
       -
       Not really. LunAST runs in roughly ~10ms on [my](https://github.com/NotNite) machine, with filtering for what modules to parse. Parsing every module takes only a second. There are future plans to cache and parallelize the process, so that load times are only slow once.

     

       116
       116
       -
       

     

       117
       117
       -
       You can measure how long LunAST took to process with the `moonlight.lunast.elapsed` variable.

     

       118
       118
       -
       

     

       119
       119
       -
       ### Does this mean patches are dead?

     

       120
       120
       -
       

     

       121
       121
       -
       No. Patches will continue to serve their purpose and be supported in moonlight, no matter what. LunAST should also work with patches, but patches may conflict or not match.

     

       122
       122
       -
       

     

       123
       123
       -
       [astring](https://github.com/davidbonnet/astring) may need to be forked in the future to output code without whitespace, in the event patches fail to match on AST-patched code.

     

       124
       124
       -
       

     

       125
       125
       -
       ### This API surface seems kind of bad

     

       126
       126
       -
       

     

       127
       127
       -
       This is still in heavy development and all suggestions on how to improve it are welcome. :3

     

       128
       128
       -
       

     

       129
       129
       -
       ### Can I help?

     

       130
       130
       -
       

     

       131
       131
       -
       Discussion takes place in the [moonlight Discord server](https://discord.gg/FdZBTFCP6F) and its `#lunast-devel` channel.

-22

packages/lunast/TODO.md

···

       1
       1
       -
       # LunAST TODO

     

       2
       2
       -
       

     

       3
       3
       -
       - [ ] Experiment more! We need to know what's bad with this

     

       4
       4
       -
       - [ ] Write utility functions for imports, exports, etc.

     

       5
       5
       -
         - [ ] Imports

     

       6
       6
       -
         - [x] Exports

     

       7
       7
       -
         - [ ] Constant bindings for an object

     

       8
       8
       -
       - [ ] Map Z/ZP to default

     

       9
       9
       -
       - [x] Steal Webpack require and use it in our LunAST instance

     

       10
       10
       -
       - [ ] Map `import` statements to LunAST

     

       11
       11
       -
       - [x] Support patching in the AST

     

       12
       12
       -
         - Let user modify the AST, have a function to flag it as modified, if it's modified we serialize it back into a string and put it back into Webpack

     

       13
       13
       -
         - We already have a `priority` system for this

     

       14
       14
       -
       - [ ] Run in parallel with service workers

     

       15
       15
       -
         - This is gonna require making Webpack entrypoint async and us doing kickoff ourselves

     

       16
       16
       -
       - [ ] Support lazy loaded chunks

     

       17
       17
       -
         - Works right now, but will break when caching is implemented

     

       18
       18
       -
       - [ ] Split into a new repo on GitHub, publish to NPM maybe

     

       19
       19
       -
       - [ ] Implement caching based off of the client build and LunAST commit

     

       20
       20
       -
         - Means you only have to have a long client start once per client build

     

       21
       21
       -
       - [ ] Process in CI to use if available on startup

     

       22
       22
       -
         - Should mean, if you're lucky, client starts only take the extra time to make the request

-14

packages/lunast/package.json

···

       1
       1
       -
       {

     

       2
       2
       -
         "name": "@moonlight-mod/lunast",

     

       3
       3
       -
         "version": "1.0.0",

     

       4
       4
       -
         "main": "./src/index.ts",

     

       5
       5
       -
         "types": "./src/index.ts",

     

       6
       6
       -
         "exports": {

     

       7
       7
       -
           ".": "./src/index.ts"

     

       8
       8
       -
         },

     

       9
       9
       -
         "dependencies": {

     

       10
       10
       -
           "astring": "^1.9.0",

     

       11
       11
       -
           "estree-toolkit": "^1.7.8",

     

       12
       12
       -
           "meriyah": "^6.0.1"

     

       13
       13
       -
         }

     

       14
       14
       -
       }

-196

packages/lunast/src/index.ts

···

       1
       1
       -
       import { RemapField, RemapModule, RemapType } from "./types";

     

       2
       2
       -
       import { Remapped } from "./modules";

     

       3
       3
       -
       import { getProcessors, parseFixed } from "./utils";

     

       4
       4
       -
       import { Processor, ProcessorState } from "./remap";

     

       5
       5
       -
       import { generate } from "astring";

     

       6
       6
       -
       

     

       7
       7
       -
       export default class LunAST {

     

       8
       8
       -
         private modules: Record<string, RemapModule>;

     

       9
       9
       -
         private types: Record<string, RemapType>;

     

       10
       10
       -
         private successful: Set<string>;

     

       11
       11
       -
       

     

       12
       12
       -
         private typeCache: Record<string, RemapType | null>;

     

       13
       13
       -
         private fieldCache: Record<

     

       14
       14
       -
           string,

     

       15
       15
       -
           Record<string | symbol, RemapField | null>

     

       16
       16
       -
         >;

     

       17
       17
       -
         private processors: Processor[];

     

       18
       18
       -
         private defaultRequire?: (id: string) => any;

     

       19
       19
       -
         private getModuleSource?: (id: string) => string;

     

       20
       20
       -
       

     

       21
       21
       -
         elapsed: number;

     

       22
       22
       -
       

     

       23
       23
       -
         constructor() {

     

       24
       24
       -
           this.modules = {};

     

       25
       25
       -
           this.types = {};

     

       26
       26
       -
           this.successful = new Set();

     

       27
       27
       -
       

     

       28
       28
       -
           this.typeCache = {};

     

       29
       29
       -
           this.fieldCache = {};

     

       30
       30
       -
           this.processors = getProcessors();

     

       31
       31
       -
       

     

       32
       32
       -
           this.elapsed = 0;

     

       33
       33
       -
         }

     

       34
       34
       -
       

     

       35
       35
       -
         public static getVersion() {

     

       36
       36
       -
           // TODO: embed version in build when we move this to a new repo

     

       37
       37
       -
           // this is here for caching based off of the lunast commit ID

     

       38
       38
       -
           return "dev";

     

       39
       39
       -
         }

     

       40
       40
       -
       

     

       41
       41
       -
         public parseScript(id: string, code: string): Record<string, string> {

     

       42
       42
       -
           const start = performance.now();

     

       43
       43
       -
       

     

       44
       44
       -
           const available = [...this.processors]

     

       45
       45
       -
             .sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0))

     

       46
       46
       -
             .filter((x) => {

     

       47
       47
       -
               if (x.find == null) return true;

     

       48
       48
       -
               const finds = Array.isArray(x.find) ? x.find : [x.find];

     

       49
       49
       -
               return finds.every((find) =>

     

       50
       50
       -
                 typeof find === "string" ? code.indexOf(find) !== -1 : find.test(code)

     

       51
       51
       -
               );

     

       52
       52
       -
             })

     

       53
       53
       -
             .filter((x) => x.manual !== true);

     

       54
       54
       -
       

     

       55
       55
       -
           const ret = this.parseScriptInternal(id, code, available);

     

       56
       56
       -
       

     

       57
       57
       -
           const end = performance.now();

     

       58
       58
       -
           this.elapsed += end - start;

     

       59
       59
       -
       

     

       60
       60
       -
           return ret;

     

       61
       61
       -
         }

     

       62
       62
       -
       

     

       63
       63
       -
         // This is like this so processors can trigger other processors while they're parsing

     

       64
       64
       -
         private parseScriptInternal(

     

       65
       65
       -
           id: string,

     

       66
       66
       -
           code: string,

     

       67
       67
       -
           processors: Processor[]

     

       68
       68
       -
         ) {

     

       69
       69
       -
           const ret: Record<string, string> = {};

     

       70
       70
       -
           if (processors.length === 0) return ret;

     

       71
       71
       -
       

     

       72
       72
       -
           // Wrap so the anonymous function is valid JS

     

       73
       73
       -
           const module = parseFixed(`(\n${code}\n)`);

     

       74
       74
       -
           let dirty = false;

     

       75
       75
       -
           const state: ProcessorState = {

     

       76
       76
       -
             id,

     

       77
       77
       -
             ast: module,

     

       78
       78
       -
             lunast: this,

     

       79
       79
       -
             markDirty: () => {

     

       80
       80
       -
               dirty = true;

     

       81
       81
       -
             },

     

       82
       82
       -
             trigger: (id, tag) => {

     

       83
       83
       -
               const source = this.getModuleSourceById(id);

     

       84
       84
       -
               if (source == null) return;

     

       85
       85
       -
               if (this.successful.has(tag)) return;

     

       86
       86
       -
               const processor = this.processors.find((x) => x.name === tag);

     

       87
       87
       -
               if (processor == null) return;

     

       88
       88
       -
               const theirRet = this.parseScriptInternal(id, source, [processor]);

     

       89
       89
       -
               Object.assign(ret, theirRet);

     

       90
       90
       -
             }

     

       91
       91
       -
           };

     

       92
       92
       -
       

     

       93
       93
       -
           for (const processor of processors) {

     

       94
       94
       -
             if (processor.process(state)) {

     

       95
       95
       -
               this.processors.splice(this.processors.indexOf(processor), 1);

     

       96
       96
       -
               this.successful.add(processor.name);

     

       97
       97
       -
             }

     

       98
       98
       -
           }

     

       99
       99
       -
       

     

       100
       100
       -
           const str = dirty ? generate(module) : null;

     

       101
       101
       -
           if (str != null) ret[id] = str;

     

       102
       102
       -
       

     

       103
       103
       -
           return ret;

     

       104
       104
       -
         }

     

       105
       105
       -
       

     

       106
       106
       -
         public getType(name: string) {

     

       107
       107
       -
           return (

     

       108
       108
       -
             this.typeCache[name] ?? (this.typeCache[name] = this.types[name] ?? null)

     

       109
       109
       -
           );

     

       110
       110
       -
         }

     

       111
       111
       -
       

     

       112
       112
       -
         public getIdForModule(name: string) {

     

       113
       113
       -
           return Object.values(this.modules).find((x) => x.name === name)?.id ?? null;

     

       114
       114
       -
         }

     

       115
       115
       -
       

     

       116
       116
       -
         public addModule(module: RemapModule) {

     

       117
       117
       -
           if (!this.modules[module.name]) {

     

       118
       118
       -
             this.modules[module.name] = module;

     

       119
       119
       -
           } else {

     

       120
       120
       -
             throw new Error(

     

       121
       121
       -
               `Module ${module.name} already registered (${

     

       122
       122
       -
                 this.modules[module.name].id

     

       123
       123
       -
               })`

     

       124
       124
       -
             );

     

       125
       125
       -
           }

     

       126
       126
       -
         }

     

       127
       127
       -
       

     

       128
       128
       -
         public addType(type: RemapType) {

     

       129
       129
       -
           if (!this.types[type.name]) {

     

       130
       130
       -
             this.types[type.name] = type;

     

       131
       131
       -
           } else {

     

       132
       132
       -
             throw new Error(`Type ${type.name} already registered`);

     

       133
       133
       -
           }

     

       134
       134
       -
         }

     

       135
       135
       -
       

     

       136
       136
       -
         public proxy(obj: any, type: RemapType): any {

     

       137
       137
       -
           const fields =

     

       138
       138
       -
             this.fieldCache[type.name] ?? (this.fieldCache[type.name] = {});

     

       139
       139
       -
       

     

       140
       140
       -
           return new Proxy(obj, {

     

       141
       141
       -
             get: (target, prop) => {

     

       142
       142
       -
               const field =

     

       143
       143
       -
                 fields[prop] ??

     

       144
       144
       -
                 (fields[prop] = type.fields.find((x) => x.name === prop) ?? null);

     

       145
       145
       -
               if (field) {

     

       146
       146
       -
                 const fieldType =

     

       147
       147
       -
                   field.type != null ? this.getType(field.type) : null;

     

       148
       148
       -
                 const name = field.unmapped ?? field.name;

     

       149
       149
       -
                 if (fieldType != null) {

     

       150
       150
       -
                   return this.proxy(target[name], fieldType);

     

       151
       151
       -
                 } else {

     

       152
       152
       -
                   return target[name];

     

       153
       153
       -
                 }

     

       154
       154
       -
               } else {

     

       155
       155
       -
                 return target[prop];

     

       156
       156
       -
               }

     

       157
       157
       -
             }

     

       158
       158
       -
           });

     

       159
       159
       -
         }

     

       160
       160
       -
       

     

       161
       161
       -
         // TODO: call this with require we obtain from the webpack entrypoint

     

       162
       162
       -
         public setDefaultRequire(require: (id: string) => any) {

     

       163
       163
       -
           this.defaultRequire = require;

     

       164
       164
       -
         }

     

       165
       165
       -
       

     

       166
       166
       -
         public setModuleSourceGetter(getSource: (id: string) => string) {

     

       167
       167
       -
           this.getModuleSource = getSource;

     

       168
       168
       -
         }

     

       169
       169
       -
       

     

       170
       170
       -
         public getModuleSourceById(id: string) {

     

       171
       171
       -
           return this.getModuleSource?.(id) ?? null;

     

       172
       172
       -
         }

     

       173
       173
       -
       

     

       174
       174
       -
         public remap<Id extends keyof Remapped>(

     

       175
       175
       -
           id: Id,

     

       176
       176
       -
           require?: (id: string) => any

     

       177
       177
       -
         ): Remapped[Id] | null {

     

       178
       178
       -
           const mappedModule = this.modules[id];

     

       179
       179
       -
           if (!mappedModule) return null;

     

       180
       180
       -
       

     

       181
       181
       -
           const realRequire = require ?? this.defaultRequire;

     

       182
       182
       -
           if (!realRequire) return null;

     

       183
       183
       -
       

     

       184
       184
       -
           const module = realRequire(mappedModule.id);

     

       185
       185
       -
           if (module == null) return null;

     

       186
       186
       -
       

     

       187
       187
       -
           const type = this.getType(mappedModule.type);

     

       188
       188
       -
           if (type != null) {

     

       189
       189
       -
             return this.proxy(module, type);

     

       190
       190
       -
           } else {

     

       191
       191
       -
             return module;

     

       192
       192
       -
           }

     

       193
       193
       -
         }

     

       194
       194
       -
       }

     

       195
       195
       -
       

     

       196
       196
       -
       export { Remapped } from "./modules";

-4

packages/lunast/src/modules.ts

···

       1
       1
       -
       // This kinda sucks, TODO figure out a better way to do this dynamically

     

       2
       2
       -
       import "./modules/test";

     

       3
       3
       -
       

     

       4
       4
       -
       export type Remapped = Record<string, never>;

-170

packages/lunast/src/modules/test.ts

···

       1
       1
       -
       import { traverse, is } from "estree-toolkit";

     

       2
       2
       -
       import { getPropertyGetters, register, magicAST, getImports } from "../utils";

     

       3
       3
       -
       import { BlockStatement } from "estree-toolkit/dist/generated/types";

     

       4
       4
       -
       

     

       5
       5
       -
       // These aren't actual modules yet, I'm just using this as a testbed for stuff

     

       6
       6
       -
       

     

       7
       7
       -
       // Exports example

     

       8
       8
       -
       /*register({

     

       9
       9
       -
         name: "ApplicationStoreDirectoryStore",

     

       10
       10
       -
         find: '"displayName","ApplicationStoreDirectoryStore"',

     

       11
       11
       -
         process({ ast }) {

     

       12
       12
       -
           const exports = getExports(ast);

     

       13
       13
       -
           return Object.keys(exports).length > 0;

     

       14
       14
       -
         }

     

       15
       15
       -
       });

     

       16
       16
       -
       

     

       17
       17
       -
       register({

     

       18
       18
       -
         name: "FluxDispatcher",

     

       19
       19
       -
         find: "addBreadcrumb:",

     

       20
       20
       -
         process({ id, ast, lunast }) {

     

       21
       21
       -
           const exports = getExports(ast);

     

       22
       22
       -
           for (const [name, data] of Object.entries(exports)) {

     

       23
       23
       -
             if (!is.identifier(data.argument)) continue;

     

       24
       24
       -
             const binding = data.scope.getOwnBinding(data.argument.name);

     

       25
       25
       -
             console.log(name, binding);

     

       26
       26
       -
           }

     

       27
       27
       -
           return false;

     

       28
       28
       -
         }

     

       29
       29
       -
       });*/

     

       30
       30
       -
       

     

       31
       31
       -
       // Patching example

     

       32
       32
       -
       register({

     

       33
       33
       -
         name: "ImagePreview",

     

       34
       34
       -
         find: ".Messages.OPEN_IN_BROWSER",

     

       35
       35
       -
         process({ id, ast, lunast, markDirty }) {

     

       36
       36
       -
           const getters = getPropertyGetters(ast);

     

       37
       37
       -
           const replacement = magicAST(`return require("common_react").createElement(

     

       38
       38
       -
         "div",

     

       39
       39
       -
         {

     

       40
       40
       -
           style: {

     

       41
       41
       -
             color: "white",

     

       42
       42
       -
           },

     

       43
       43
       -
         },

     

       44
       44
       -
         "balls"

     

       45
       45
       -
       )`)!;

     

       46
       46
       -
           for (const data of Object.values(getters)) {

     

       47
       47
       -
             if (!is.identifier(data.expression)) continue;

     

       48
       48
       -
       

     

       49
       49
       -
             const node = data.scope.getOwnBinding(data.expression.name);

     

       50
       50
       -
             if (!node) continue;

     

       51
       51
       -
       

     

       52
       52
       -
             const body = node.path.get<BlockStatement>("body");

     

       53
       53
       -
             body.replaceWith(replacement);

     

       54
       54
       -
           }

     

       55
       55
       -
           markDirty();

     

       56
       56
       -
       

     

       57
       57
       -
           return true;

     

       58
       58
       -
         }

     

       59
       59
       -
       });

     

       60
       60
       -
       

     

       61
       61
       -
       // Remapping example

     

       62
       62
       -
       register({

     

       63
       63
       -
         name: "ClipboardUtils",

     

       64
       64
       -
         find: 'document.queryCommandEnabled("copy")',

     

       65
       65
       -
         process({ id, ast, lunast }) {

     

       66
       66
       -
           const getters = getPropertyGetters(ast);

     

       67
       67
       -
           const fields = [];

     

       68
       68
       -
       

     

       69
       69
       -
           for (const [name, data] of Object.entries(getters)) {

     

       70
       70
       -
             if (!is.identifier(data.expression)) continue;

     

       71
       71
       -
             const node = data.scope.getOwnBinding(data.expression.name);

     

       72
       72
       -
             if (!node) continue;

     

       73
       73
       -
       

     

       74
       74
       -
             let isSupportsCopy = false;

     

       75
       75
       -
             traverse(node.path.node!, {

     

       76
       76
       -
               MemberExpression(path) {

     

       77
       77
       -
                 if (

     

       78
       78
       -
                   is.identifier(path.node?.property) &&

     

       79
       79
       -
                   path.node?.property.name === "queryCommandEnabled"

     

       80
       80
       -
                 ) {

     

       81
       81
       -
                   isSupportsCopy = true;

     

       82
       82
       -
                   this.stop();

     

       83
       83
       -
                 }

     

       84
       84
       -
               }

     

       85
       85
       -
             });

     

       86
       86
       -
       

     

       87
       87
       -
             if (isSupportsCopy) {

     

       88
       88
       -
               fields.push({

     

       89
       89
       -
                 name: "SUPPORTS_COPY",

     

       90
       90
       -
                 unmapped: name

     

       91
       91
       -
               });

     

       92
       92
       -
             } else {

     

       93
       93
       -
               fields.push({

     

       94
       94
       -
                 name: "copy",

     

       95
       95
       -
                 unmapped: name

     

       96
       96
       -
               });

     

       97
       97
       -
             }

     

       98
       98
       -
           }

     

       99
       99
       -
       

     

       100
       100
       -
           if (fields.length > 0) {

     

       101
       101
       -
             lunast.addType({

     

       102
       102
       -
               name: "ClipboardUtils",

     

       103
       103
       -
               fields

     

       104
       104
       -
             });

     

       105
       105
       -
             lunast.addModule({

     

       106
       106
       -
               name: "ClipboardUtils",

     

       107
       107
       -
               id,

     

       108
       108
       -
               type: "ClipboardUtils"

     

       109
       109
       -
             });

     

       110
       110
       -
             return true;

     

       111
       111
       -
           }

     

       112
       112
       -
       

     

       113
       113
       -
           return false;

     

       114
       114
       -
         }

     

       115
       115
       -
       });

     

       116
       116
       -
       

     

       117
       117
       -
       // Parse all modules to demonstrate speed loss

     

       118
       118
       -
       /*register({

     

       119
       119
       -
         name: "AllModules",

     

       120
       120
       -
         process({ id, ast, lunast }) {

     

       121
       121
       -
           return false;

     

       122
       122
       -
         }

     

       123
       123
       -
       });*/

     

       124
       124
       -
       

     

       125
       125
       -
       // Triggering a processor from another processor

     

       126
       126
       -
       register({

     

       127
       127
       -
         name: "FluxDispatcherParent",

     

       128
       128
       -
         find: ["isDispatching", "dispatch", "googlebot"],

     

       129
       129
       -
         process({ id, ast, lunast, trigger }) {

     

       130
       130
       -
           const imports = getImports(ast);

     

       131
       131
       -
           // This is so stupid lol

     

       132
       132
       -
           const usages = Object.entries(imports)

     

       133
       133
       -
             .map(([name, data]): [string, number] => {

     

       134
       134
       -
               if (!is.identifier(data.expression)) return [name, 0];

     

       135
       135
       -
               const binding = data.scope.getOwnBinding(data.expression.name);

     

       136
       136
       -
               if (!binding) return [name, 0];

     

       137
       137
       -
               return [name, binding.references.length];

     

       138
       138
       -
             })

     

       139
       139
       -
             .sort(([, a], [, b]) => b! - a!)

     

       140
       140
       -
             .map(([name]) => name);

     

       141
       141
       -
       

     

       142
       142
       -
           const dispatcher = usages[1].toString();

     

       143
       143
       -
           trigger(dispatcher, "FluxDispatcher");

     

       144
       144
       -
           return true;

     

       145
       145
       -
         }

     

       146
       146
       -
       });

     

       147
       147
       -
       

     

       148
       148
       -
       register({

     

       149
       149
       -
         name: "FluxDispatcher",

     

       150
       150
       -
         manual: true,

     

       151
       151
       -
         process({ id, ast, lunast }) {

     

       152
       152
       -
           lunast.addModule({

     

       153
       153
       -
             name: "FluxDispatcher",

     

       154
       154
       -
             id,

     

       155
       155
       -
             type: "FluxDispatcher"

     

       156
       156
       -
           });

     

       157
       157
       -
       

     

       158
       158
       -
           lunast.addType({

     

       159
       159
       -
             name: "FluxDispatcher",

     

       160
       160
       -
             fields: [

     

       161
       161
       -
               {

     

       162
       162
       -
                 name: "default",

     

       163
       163
       -
                 unmapped: "Z"

     

       164
       164
       -
               }

     

       165
       165
       -
             ]

     

       166
       166
       -
           });

     

       167
       167
       -
       

     

       168
       168
       -
           return true;

     

       169
       169
       -
         }

     

       170
       170
       -
       });

-17

packages/lunast/src/remap.ts

···

       1
       1
       -
       import type LunAST from ".";

     

       2
       2
       -
       import type { Program } from "estree-toolkit/dist/generated/types";

     

       3
       3
       -
       

     

       4
       4
       -
       export type Processor = {

     

       5
       5
       -
         name: string;

     

       6
       6
       -
         find?: (string | RegExp)[] | (string | RegExp);

     

       7
       7
       -
         priority?: number;

     

       8
       8
       -
         manual?: boolean;

     

       9
       9
       -
         process: (state: ProcessorState) => boolean;

     

       10
       10
       -
       };

     

       11
       11
       -
       export type ProcessorState = {

     

       12
       12
       -
         id: string;

     

       13
       13
       -
         ast: Program;

     

       14
       14
       -
         lunast: LunAST;

     

       15
       15
       -
         markDirty: () => void;

     

       16
       16
       -
         trigger: (id: string, tag: string) => void;

     

       17
       17
       -
       };

-16

packages/lunast/src/types.ts

···

       1
       1
       -
       export type RemapModule = {

     

       2
       2
       -
         name: string; // the name you require it by in your code

     

       3
       3
       -
         id: string; // the resolved webpack module ID (usually a number)

     

       4
       4
       -
         type: string;

     

       5
       5
       -
       };

     

       6
       6
       -
       

     

       7
       7
       -
       export type RemapType = {

     

       8
       8
       -
         name: string;

     

       9
       9
       -
         fields: RemapField[];

     

       10
       10
       -
       };

     

       11
       11
       -
       

     

       12
       12
       -
       export type RemapField = {

     

       13
       13
       -
         name: string; // the name of the field in the proxy (human readable)

     

       14
       14
       -
         unmapped?: string; // the name of the field in discord source (minified)

     

       15
       15
       -
         type?: string;

     

       16
       16
       -
       };

-211

packages/lunast/src/utils.ts

···

       1
       1
       -
       import type { Processor } from "./remap";

     

       2
       2
       -
       import { traverse, is, Scope, Binding, NodePath } from "estree-toolkit";

     

       3
       3
       -
       // FIXME something's fishy with these types

     

       4
       4
       -
       import type {

     

       5
       5
       -
         Expression,

     

       6
       6
       -
         ExpressionStatement,

     

       7
       7
       -
         ObjectExpression,

     

       8
       8
       -
         Program,

     

       9
       9
       -
         ReturnStatement

     

       10
       10
       -
       } from "estree-toolkit/dist/generated/types";

     

       11
       11
       -
       import { parse } from "meriyah";

     

       12
       12
       -
       

     

       13
       13
       -
       export const processors: Processor[] = [];

     

       14
       14
       -
       

     

       15
       15
       -
       export function register(processor: Processor) {

     

       16
       16
       -
         processors.push(processor);

     

       17
       17
       -
       }

     

       18
       18
       -
       

     

       19
       19
       -
       export function getProcessors() {

     

       20
       20
       -
         // Clone the array to prevent mutation

     

       21
       21
       -
         return [...processors];

     

       22
       22
       -
       }

     

       23
       23
       -
       

     

       24
       24
       -
       export type ExpressionWithScope = {

     

       25
       25
       -
         expression: Expression;

     

       26
       26
       -
         scope: Scope;

     

       27
       27
       -
       };

     

       28
       28
       -
       

     

       29
       29
       -
       function getParent(path: NodePath) {

     

       30
       30
       -
         let parent = path.parentPath;

     

       31
       31
       -
         while (!is.program(parent)) {

     

       32
       32
       -
           parent = parent?.parentPath ?? null;

     

       33
       33
       -
           if (

     

       34
       34
       -
             parent == null ||

     

       35
       35
       -
             parent.node == null ||

     

       36
       36
       -
             ![

     

       37
       37
       -
               "FunctionExpression",

     

       38
       38
       -
               "ExpressionStatement",

     

       39
       39
       -
               "CallExpression",

     

       40
       40
       -
               "Program"

     

       41
       41
       -
             ].includes(parent.node.type)

     

       42
       42
       -
           ) {

     

       43
       43
       -
             return null;

     

       44
       44
       -
           }

     

       45
       45
       -
         }

     

       46
       46
       -
       

     

       47
       47
       -
         if (!is.functionExpression(path.parent)) return null;

     

       48
       48
       -
         return path.parent;

     

       49
       49
       -
       }

     

       50
       50
       -
       

     

       51
       51
       -
       export function getExports(ast: Program) {

     

       52
       52
       -
         const ret: Record<string, ExpressionWithScope> = {};

     

       53
       53
       -
       

     

       54
       54
       -
         traverse(ast, {

     

       55
       55
       -
           $: { scope: true },

     

       56
       56
       -
           BlockStatement(path) {

     

       57
       57
       -
             if (path.scope == null) return;

     

       58
       58
       -
             const parent = getParent(path);

     

       59
       59
       -
             if (parent == null) return;

     

       60
       60
       -
       

     

       61
       61
       -
             for (let i = 0; i < parent.params.length; i++) {

     

       62
       62
       -
               const param = parent.params[i];

     

       63
       63
       -
               if (!is.identifier(param)) continue;

     

       64
       64
       -
               const binding: Binding | undefined = path.scope!.getBinding(param.name);

     

       65
       65
       -
               if (!binding) continue;

     

       66
       66
       -
       

     

       67
       67
       -
               // module

     

       68
       68
       -
               if (i === 0) {

     

       69
       69
       -
                 for (const reference of binding.references) {

     

       70
       70
       -
                   if (!is.identifier(reference.node)) continue;

     

       71
       71
       -
                   if (!is.assignmentExpression(reference.parentPath?.parentPath))

     

       72
       72
       -
                     continue;

     

       73
       73
       -
       

     

       74
       74
       -
                   const exportsNode = reference.parentPath?.parentPath.node;

     

       75
       75
       -
                   if (!is.memberExpression(exportsNode?.left)) continue;

     

       76
       76
       -
                   if (!is.identifier(exportsNode.left.property)) continue;

     

       77
       77
       -
                   if (exportsNode.left.property.name !== "exports") continue;

     

       78
       78
       -
       

     

       79
       79
       -
                   const exports = exportsNode?.right;

     

       80
       80
       -
                   if (!is.objectExpression(exports)) continue;

     

       81
       81
       -
       

     

       82
       82
       -
                   for (const property of exports.properties) {

     

       83
       83
       -
                     if (!is.property(property)) continue;

     

       84
       84
       -
                     if (!is.identifier(property.key)) continue;

     

       85
       85
       -
                     if (!is.expression(property.value)) continue;

     

       86
       86
       -
                     ret[property.key.name] = {

     

       87
       87
       -
                       expression: property.value,

     

       88
       88
       -
                       scope: path.scope

     

       89
       89
       -
                     };

     

       90
       90
       -
                   }

     

       91
       91
       -
                 }

     

       92
       92
       -
               }

     

       93
       93
       -
               // TODO: exports

     

       94
       94
       -
               else if (i === 1) {

     

       95
       95
       -
                 for (const reference of binding.references) {

     

       96
       96
       -
                   if (!is.identifier(reference.node)) continue;

     

       97
       97
       -
                   if (reference.parentPath == null) continue;

     

       98
       98
       -
                   if (!is.memberExpression(reference.parentPath.node)) continue;

     

       99
       99
       -
                   if (!is.identifier(reference.parentPath.node.property)) continue;

     

       100
       100
       -
       

     

       101
       101
       -
                   const assignmentExpression = reference.parentPath.parentPath?.node;

     

       102
       102
       -
                   if (!is.assignmentExpression(assignmentExpression)) continue;

     

       103
       103
       -
       

     

       104
       104
       -
                   ret[reference.parentPath.node.property.name] = {

     

       105
       105
       -
                     expression: assignmentExpression.right,

     

       106
       106
       -
                     scope: path.scope

     

       107
       107
       -
                   };

     

       108
       108
       -
                 }

     

       109
       109
       -
               }

     

       110
       110
       -
             }

     

       111
       111
       -
           }

     

       112
       112
       -
         });

     

       113
       113
       -
       

     

       114
       114
       -
         return ret;

     

       115
       115
       -
       }

     

       116
       116
       -
       

     

       117
       117
       -
       // TODO: util function to resolve the value of an expression

     

       118
       118
       -
       export function getPropertyGetters(ast: Program) {

     

       119
       119
       -
         const ret: Record<string, ExpressionWithScope> = {};

     

       120
       120
       -
       

     

       121
       121
       -
         traverse(ast, {

     

       122
       122
       -
           $: { scope: true },

     

       123
       123
       -
           CallExpression(path) {

     

       124
       124
       -
             if (path.scope == null) return;

     

       125
       125
       -
             if (!is.callExpression(path.node)) return;

     

       126
       126
       -
             if (!is.memberExpression(path.node.callee)) return;

     

       127
       127
       -
             if (!is.identifier(path.node?.callee?.property)) return;

     

       128
       128
       -
             if (path.node.callee.property.name !== "d") return;

     

       129
       129
       -
       

     

       130
       130
       -
             const arg = path.node.arguments.find((node): node is ObjectExpression =>

     

       131
       131
       -
               is.objectExpression(node)

     

       132
       132
       -
             );

     

       133
       133
       -
             if (!arg) return;

     

       134
       134
       -
       

     

       135
       135
       -
             for (const property of arg.properties) {

     

       136
       136
       -
               if (!is.property(property)) continue;

     

       137
       137
       -
               if (!is.identifier(property.key)) continue;

     

       138
       138
       -
               if (!is.functionExpression(property.value)) continue;

     

       139
       139
       -
               if (!is.blockStatement(property.value.body)) continue;

     

       140
       140
       -
       

     

       141
       141
       -
               const returnStatement = property.value.body.body.find(

     

       142
       142
       -
                 (node): node is ReturnStatement => is.returnStatement(node)

     

       143
       143
       -
               );

     

       144
       144
       -
               if (!returnStatement || !returnStatement.argument) continue;

     

       145
       145
       -
               ret[property.key.name] = {

     

       146
       146
       -
                 expression: returnStatement.argument,

     

       147
       147
       -
                 scope: path.scope

     

       148
       148
       -
               };

     

       149
       149
       -
             }

     

       150
       150
       -
       

     

       151
       151
       -
             this.stop();

     

       152
       152
       -
           }

     

       153
       153
       -
         });

     

       154
       154
       -
       

     

       155
       155
       -
         return ret;

     

       156
       156
       -
       }

     

       157
       157
       -
       

     

       158
       158
       -
       // The ESTree types are mismatched with estree-toolkit, but ESTree is a standard so this is fine

     

       159
       159
       -
       export function parseFixed(code: string): Program {

     

       160
       160
       -
         return parse(code) as any as Program;

     

       161
       161
       -
       }

     

       162
       162
       -
       

     

       163
       163
       -
       export function magicAST(code: string) {

     

       164
       164
       -
         // Wraps code in an IIFE so you can type `return` and all that goodies

     

       165
       165
       -
         // Might not work for some other syntax issues but oh well

     

       166
       166
       -
         const tree = parse("(()=>{" + code + "})()");

     

       167
       167
       -
       

     

       168
       168
       -
         const expressionStatement = tree.body[0] as ExpressionStatement;

     

       169
       169
       -
         if (!is.expressionStatement(expressionStatement)) return null;

     

       170
       170
       -
         if (!is.callExpression(expressionStatement.expression)) return null;

     

       171
       171
       -
         if (!is.arrowFunctionExpression(expressionStatement.expression.callee))

     

       172
       172
       -
           return null;

     

       173
       173
       -
         if (!is.blockStatement(expressionStatement.expression.callee.body))

     

       174
       174
       -
           return null;

     

       175
       175
       -
         return expressionStatement.expression.callee.body;

     

       176
       176
       -
       }

     

       177
       177
       -
       

     

       178
       178
       -
       export function getImports(ast: Program) {

     

       179
       179
       -
         const ret: Record<string, ExpressionWithScope> = {};

     

       180
       180
       -
       

     

       181
       181
       -
         traverse(ast, {

     

       182
       182
       -
           $: { scope: true },

     

       183
       183
       -
           BlockStatement(path) {

     

       184
       184
       -
             if (path.scope == null) return;

     

       185
       185
       -
             const parent = getParent(path);

     

       186
       186
       -
             if (parent == null) return;

     

       187
       187
       -
       

     

       188
       188
       -
             const require = parent.params[2];

     

       189
       189
       -
             if (!is.identifier(require)) return;

     

       190
       190
       -
             const references = path.scope.getOwnBinding(require.name)?.references;

     

       191
       191
       -
             if (references == null) return;

     

       192
       192
       -
             for (const reference of references) {

     

       193
       193
       -
               if (!is.callExpression(reference.parentPath)) continue;

     

       194
       194
       -
               if (reference.parentPath.node?.arguments.length !== 1) continue;

     

       195
       195
       -
               if (!is.variableDeclarator(reference.parentPath.parentPath)) continue;

     

       196
       196
       -
               if (!is.identifier(reference.parentPath.parentPath.node?.id)) continue;

     

       197
       197
       -
       

     

       198
       198
       -
               const moduleId = reference.parentPath.node.arguments[0];

     

       199
       199
       -
               if (!is.literal(moduleId)) continue;

     

       200
       200
       -
               if (moduleId.value == null) continue;

     

       201
       201
       -
       

     

       202
       202
       -
               ret[moduleId.value.toString()] = {

     

       203
       203
       -
                 expression: reference.parentPath.parentPath.node.id,

     

       204
       204
       -
                 scope: path.scope

     

       205
       205
       -
               };

     

       206
       206
       -
             }

     

       207
       207
       -
           }

     

       208
       208
       -
         });

     

       209
       209
       -
       

     

       210
       210
       -
         return ret;

     

       211
       211
       -
       }

-3

packages/lunast/tsconfig.json

···

       1
       1
       -
       {

     

       2
       2
       -
         "extends": "../../tsconfig.json"

     

       3
       3
       -
       }

+2 -1

packages/types/package.json

···

       9
       9
        
           "./*": "./src/*.ts"

     

       10
       10
        
         },

     

       11
       11
        
         "dependencies": {

     

       12
       12
       -
           "@moonlight-mod/lunast": "workspace:*",

     

       12
       12
       +
           "@moonlight-mod/lunast": "git+https://github.com/moonlight-mod/lunast.git",

     

       13
       13
       +
           "@moonlight-mod/moonmap": "git+https://github.com/moonlight-mod/moonmap.git",

     

       13
       14
        
           "@types/flux": "^3.1.12",

     

       14
       15
        
           "@types/react": "^18.2.22",

     

       15
       16
        
           "csstype": "^3.1.2",

packages/types/src/globals.ts

···

       8
       8
        
       } from "./extension";

     

       9
       9
        
       import type EventEmitter from "events";

     

       10
       10
        
       import type LunAST from "@moonlight-mod/lunast";

     

       11
       11
       +
       import type Moonmap from "@moonlight-mod/moonmap";

     

       11
       12
        
       

     

       12
       13
        
       export type MoonlightHost = {

     

       13
       14
        
         asarPath: string;

     
···

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

     

       47
       48
        
         getLogger: (id: string) => Logger;

     

       48
       49
        
         lunast: LunAST;

     

       50
       50
       +
         moonmap: Moonmap;

     

       49
       51
        
       };

     

       50
       52
        
       

     

       51
       53
        
       export enum MoonlightEnv {

packages/types/src/index.ts

···

       19
       19
        
       export * from "./logger";

     

       20
       20
        
       export * as constants from "./constants";

     

       21
       21
        
       

     

       22
       22
       +
       export type { AST } from "@moonlight-mod/lunast";

     

       23
       23
       +
       export { ModuleExport, ModuleExportType } from "@moonlight-mod/moonmap";

     

       24
       24
       +
       

     

       22
       25
        
       declare global {

     

       23
       26
        
         const MOONLIGHT_ENV: MoonlightEnv;

     

       24
       27
        
         const MOONLIGHT_PROD: boolean;

+3 -1

packages/web-preload/package.json

···

       3
       3
        
         "private": true,

     

       4
       4
        
         "dependencies": {

     

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

     

       6
       6
       -
           "@moonlight-mod/lunast": "workspace:*"

     

       6
       6
       +
           "@moonlight-mod/lunast": "git+https://github.com/moonlight-mod/lunast.git",

     

       7
       7
       +
           "@moonlight-mod/moonmap": "git+https://github.com/moonlight-mod/moonmap.git",

     

       8
       8
       +
           "@moonlight-mod/mappings": "git+https://github.com/moonlight-mod/mappings.git"

     

       7
       9
        
         }

     

       8
       10
        
       }

+5 -1

packages/web-preload/src/index.ts

···

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

     

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

     

       5
       5
        
       import LunAST from "@moonlight-mod/lunast";

     

       6
       6
       +
       import Moonmap from "@moonlight-mod/moonmap";

     

       7
       7
       +
       import loadMappings from "@moonlight-mod/mappings";

     

       6
       8
        
       

     

       7
       9
        
       (async () => {

     

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

     
···

       18
       20
        
           getLogger(id) {

     

       19
       21
        
             return new Logger(id);

     

       20
       22
        
           },

     

       21
       21
       -
           lunast: new LunAST()

     

       23
       23
       +
           lunast: new LunAST(),

     

       24
       24
       +
           moonmap: new Moonmap()

     

       22
       25
        
         };

     

       23
       26
        
       

     

       24
       27
        
         try {

     

       28
       28
       +
           loadMappings(window.moonlight.moonmap, window.moonlight.lunast);

     

       25
       29
        
           await loadProcessedExtensions(moonlightNode.processedExtensions);

     

       26
       30
        
           await installWebpackPatcher();

     

       27
       31
        
         } catch (e) {

+46 -18

pnpm-lock.yaml

···

       45
       45
        
         packages/core:

     

       46
       46
        
           dependencies:

     

       47
       47
        
             '@moonlight-mod/lunast':

     

       48
       48
       -
               specifier: workspace:*

     

       49
       49
       -
               version: link:../lunast

     

       48
       48
       +
               specifier: git+https://github.com/moonlight-mod/lunast.git

     

       49
       49
       +
               version: https://codeload.github.com/moonlight-mod/lunast/tar.gz/af98b963bf8b6d00301229b094811a55f96eca0a

     

       50
       50
       +
             '@moonlight-mod/moonmap':

     

       51
       51
       +
               specifier: git+https://github.com/moonlight-mod/moonmap.git

     

       52
       52
       +
               version: https://codeload.github.com/moonlight-mod/moonmap/tar.gz/79cfb0f84f62c910ff6eb3cf314e045110b9d319

     

       50
       53
        
             '@moonlight-mod/types':

     

       51
       54
        
               specifier: workspace:*

     

       52
       55
        
               version: link:../types

     
···

       69
       72
        
               specifier: workspace:*

     

       70
       73
        
               version: link:../types

     

       71
       74
        
       

     

       72
       72
       -
         packages/lunast:

     

       73
       73
       -
           dependencies:

     

       74
       74
       -
             astring:

     

       75
       75
       -
               specifier: ^1.9.0

     

       76
       76
       -
               version: 1.9.0

     

       77
       77
       -
             estree-toolkit:

     

       78
       78
       -
               specifier: ^1.7.8

     

       79
       79
       -
               version: 1.7.8

     

       80
       80
       -
             meriyah:

     

       81
       81
       -
               specifier: ^6.0.1

     

       82
       82
       -
               version: 6.0.1

     

       83
       83
       -
       

     

       84
       75
        
         packages/node-preload:

     

       85
       76
        
           dependencies:

     

       86
       77
        
             '@moonlight-mod/core':

     
···

       93
       84
        
         packages/types:

     

       94
       85
        
           dependencies:

     

       95
       86
        
             '@moonlight-mod/lunast':

     

       96
       96
       -
               specifier: workspace:*

     

       97
       97
       -
               version: link:../lunast

     

       87
       87
       +
               specifier: git+https://github.com/moonlight-mod/lunast.git

     

       88
       88
       +
               version: https://codeload.github.com/moonlight-mod/lunast/tar.gz/af98b963bf8b6d00301229b094811a55f96eca0a

     

       89
       89
       +
             '@moonlight-mod/moonmap':

     

       90
       90
       +
               specifier: git+https://github.com/moonlight-mod/moonmap.git

     

       91
       91
       +
               version: https://codeload.github.com/moonlight-mod/moonmap/tar.gz/79cfb0f84f62c910ff6eb3cf314e045110b9d319

     

       98
       92
        
             '@types/flux':

     

       99
       93
        
               specifier: ^3.1.12

     

       100
       94
        
               version: 3.1.12

     
···

       114
       108
        
               specifier: workspace:*

     

       115
       109
        
               version: link:../core

     

       116
       110
        
             '@moonlight-mod/lunast':

     

       117
       117
       -
               specifier: workspace:*

     

       118
       118
       -
               version: link:../lunast

     

       111
       111
       +
               specifier: git+https://github.com/moonlight-mod/lunast.git

     

       112
       112
       +
               version: https://codeload.github.com/moonlight-mod/lunast/tar.gz/af98b963bf8b6d00301229b094811a55f96eca0a

     

       113
       113
       +
             '@moonlight-mod/mappings':

     

       114
       114
       +
               specifier: git+https://github.com/moonlight-mod/mappings.git

     

       115
       115
       +
               version: https://codeload.github.com/moonlight-mod/mappings/tar.gz/8512c9df931a4a62a03e23c64a7d378602806128(@moonlight-mod/lunast@https://codeload.github.com/moonlight-mod/lunast/tar.gz/af98b963bf8b6d00301229b094811a55f96eca0a)(@moonlight-mod/moonmap@https://codeload.github.com/moonlight-mod/moonmap/tar.gz/79cfb0f84f62c910ff6eb3cf314e045110b9d319)

     

       116
       116
       +
             '@moonlight-mod/moonmap':

     

       117
       117
       +
               specifier: git+https://github.com/moonlight-mod/moonmap.git

     

       118
       118
       +
               version: https://codeload.github.com/moonlight-mod/moonmap/tar.gz/79cfb0f84f62c910ff6eb3cf314e045110b9d319

     

       119
       119
        
       

     

       120
       120
        
       packages:

     

       121
       121
        
       

     
···

       290
       290
        
         '@humanwhocodes/object-schema@2.0.1':

     

       291
       291
        
           resolution: {integrity: sha512-dvuCeX5fC9dXgJn9t+X5atfmgQAzUOWqS1254Gh0m6i8wKd10ebXkfNKiRK+1GWi/yTvvLDHpoxLr0xxxeslWw==}

     

       292
       292
        
           deprecated: Use @eslint/object-schema instead

     

       293
       293
       +
       

     

       294
       294
       +
         '@moonlight-mod/lunast@https://codeload.github.com/moonlight-mod/lunast/tar.gz/af98b963bf8b6d00301229b094811a55f96eca0a':

     

       295
       295
       +
           resolution: {tarball: https://codeload.github.com/moonlight-mod/lunast/tar.gz/af98b963bf8b6d00301229b094811a55f96eca0a}

     

       296
       296
       +
           version: 1.0.0

     

       297
       297
       +
       

     

       298
       298
       +
         '@moonlight-mod/mappings@https://codeload.github.com/moonlight-mod/mappings/tar.gz/8512c9df931a4a62a03e23c64a7d378602806128':

     

       299
       299
       +
           resolution: {tarball: https://codeload.github.com/moonlight-mod/mappings/tar.gz/8512c9df931a4a62a03e23c64a7d378602806128}

     

       300
       300
       +
           version: 1.0.0

     

       301
       301
       +
           peerDependencies:

     

       302
       302
       +
             '@moonlight-mod/lunast': git+https://github.com/moonlight-mod/lunast.git

     

       303
       303
       +
             '@moonlight-mod/moonmap': git+https://github.com/moonlight-mod/moonmap.git

     

       304
       304
       +
       

     

       305
       305
       +
         '@moonlight-mod/moonmap@https://codeload.github.com/moonlight-mod/moonmap/tar.gz/79cfb0f84f62c910ff6eb3cf314e045110b9d319':

     

       306
       306
       +
           resolution: {tarball: https://codeload.github.com/moonlight-mod/moonmap/tar.gz/79cfb0f84f62c910ff6eb3cf314e045110b9d319}

     

       307
       307
       +
           version: 1.0.0

     

       293
       308
        
       

     

       294
       309
        
         '@nodelib/fs.scandir@2.1.5':

     

       295
       310
        
           resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}

     
···

       1454
       1469
        
         '@humanwhocodes/module-importer@1.0.1': {}

     

       1455
       1470
        
       

     

       1456
       1471
        
         '@humanwhocodes/object-schema@2.0.1': {}

     

       1472
       1472
       +
       

     

       1473
       1473
       +
         '@moonlight-mod/lunast@https://codeload.github.com/moonlight-mod/lunast/tar.gz/af98b963bf8b6d00301229b094811a55f96eca0a':

     

       1474
       1474
       +
           dependencies:

     

       1475
       1475
       +
             astring: 1.9.0

     

       1476
       1476
       +
             estree-toolkit: 1.7.8

     

       1477
       1477
       +
             meriyah: 6.0.1

     

       1478
       1478
       +
       

     

       1479
       1479
       +
         '@moonlight-mod/mappings@https://codeload.github.com/moonlight-mod/mappings/tar.gz/8512c9df931a4a62a03e23c64a7d378602806128(@moonlight-mod/lunast@https://codeload.github.com/moonlight-mod/lunast/tar.gz/af98b963bf8b6d00301229b094811a55f96eca0a)(@moonlight-mod/moonmap@https://codeload.github.com/moonlight-mod/moonmap/tar.gz/79cfb0f84f62c910ff6eb3cf314e045110b9d319)':

     

       1480
       1480
       +
           dependencies:

     

       1481
       1481
       +
             '@moonlight-mod/lunast': https://codeload.github.com/moonlight-mod/lunast/tar.gz/af98b963bf8b6d00301229b094811a55f96eca0a

     

       1482
       1482
       +
             '@moonlight-mod/moonmap': https://codeload.github.com/moonlight-mod/moonmap/tar.gz/79cfb0f84f62c910ff6eb3cf314e045110b9d319

     

       1483
       1483
       +
       

     

       1484
       1484
       +
         '@moonlight-mod/moonmap@https://codeload.github.com/moonlight-mod/moonmap/tar.gz/79cfb0f84f62c910ff6eb3cf314e045110b9d319': {}

     

       1457
       1485
        
       

     

       1458
       1486
        
         '@nodelib/fs.scandir@2.1.5':

     

       1459
       1487
        
           dependencies: