commit ad802f7e6af4c05573648fcedcff674f44cbe5b3 · notnite.com/moonlight

+42 -29

packages/core/src/patch.ts

···

       43
       43
        
       const patched: Record<string, Array<string>> = {};

     

       44
       44
        
       

     

       45
       45
        
       function patchModules(entry: WebpackJsonpEntry[1]) {

     

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

     

       47
       47
       -
           // `function(e,t,n){}` isn't valid I guess? so make it an IIFE to make ESTree happy

     

       48
       48
       -
           moonlight.lunast.parseScript(id, `(${func.toString()})()`);

     

       46
       46
       +
         function patchModule(id: string, patchId: string, replaced: string) {

     

       47
       47
       +
           // Store what extensions patched what modules for easier debugging

     

       48
       48
       +
           patched[id] = patched[id] || [];

     

       49
       49
       +
           patched[id].push(patchId);

     

       49
       50
        
       

     

       50
       50
       -
           let moduleString = Object.prototype.hasOwnProperty.call(moduleCache, id)

     

       51
       51
       +
           // Webpack module arguments are minified, so we replace them with consistent names

     

       52
       52
       +
           // We have to wrap it so things don't break, though

     

       53
       53
       +
           const patchedStr = patched[id].sort().join(", ");

     

       54
       54
       +
       

     

       55
       55
       +
           const wrapped =

     

       56
       56
       +
             `(${replaced}).apply(this, arguments)\n` +

     

       57
       57
       +
             `// Patched by moonlight: ${patchedStr}\n` +

     

       58
       58
       +
             `//# sourceURL=Webpack-Module-${id}`;

     

       59
       59
       +
       

     

       60
       60
       +
           try {

     

       61
       61
       +
             const func = new Function(

     

       62
       62
       +
               "module",

     

       63
       63
       +
               "exports",

     

       64
       64
       +
               "require",

     

       65
       65
       +
               wrapped

     

       66
       66
       +
             ) as WebpackModuleFunc;

     

       67
       67
       +
             entry[id] = func;

     

       68
       68
       +
             entry[id].__moonlight = true;

     

       69
       69
       +
             return true;

     

       70
       70
       +
           } catch (e) {

     

       71
       71
       +
             logger.warn("Error constructing function for patch", patchId, e);

     

       72
       72
       +
             patched[id].pop();

     

       73
       73
       +
             return false;

     

       74
       74
       +
           }

     

       75
       75
       +
         }

     

       76
       76
       +
       

     

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

     

       78
       78
       +
           let moduleString = Object.hasOwn(moduleCache, id)

     

       51
       79
        
             ? moduleCache[id]

     

       52
       80
        
             : func.toString().replace(/\n/g, "");

     

       53
       81
        
       

     
···

       103
       131
        
                   continue;

     

       104
       132
        
                 }

     

       105
       133
        
       

     

       106
       106
       -
                 // Store what extensions patched what modules for easier debugging

     

       107
       107
       -
                 patched[id] = patched[id] || [];

     

       108
       108
       -
                 patched[id].push(`${patch.ext}#${patch.id}`);

     

       109
       109
       -
       

     

       110
       110
       -
                 // Webpack module arguments are minified, so we replace them with consistent names

     

       111
       111
       -
                 // We have to wrap it so things don't break, though

     

       112
       112
       -
                 const patchedStr = patched[id].sort().join(", ");

     

       113
       113
       -
       

     

       114
       114
       -
                 const wrapped =

     

       115
       115
       -
                   `(${replaced}).apply(this, arguments)\n` +

     

       116
       116
       -
                   `// Patched by moonlight: ${patchedStr}\n` +

     

       117
       117
       -
                   `//# sourceURL=Webpack-Module-${id}`;

     

       118
       118
       -
       

     

       119
       119
       -
                 try {

     

       120
       120
       -
                   const func = new Function(

     

       121
       121
       -
                     "module",

     

       122
       122
       -
                     "exports",

     

       123
       123
       -
                     "require",

     

       124
       124
       -
                     wrapped

     

       125
       125
       -
                   ) as WebpackModuleFunc;

     

       126
       126
       -
                   entry[id] = func;

     

       127
       127
       -
                   entry[id].__moonlight = true;

     

       134
       134
       +
                 if (patchModule(id, `${patch.ext}#${patch.id}`, replaced)) {

     

       128
       135
        
                   moduleString = replaced;

     

       129
       129
       -
                 } catch (e) {

     

       130
       130
       -
                   logger.warn("Error constructing function for patch", patch, e);

     

       131
       131
       -
                   patched[id].pop();

     

       132
       136
        
                 }

     

       133
       137
        
               } else if (replace.type === PatchReplaceType.Module) {

     

       134
       138
        
                 // Directly replace the module with a new one

     
···

       143
       147
        
               if (shouldRemove) {

     

       144
       148
        
                 patches.splice(i--, 1);

     

       145
       149
        
               }

     

       150
       150
       +
             }

     

       151
       151
       +
           }

     

       152
       152
       +
       

     

       153
       153
       +
           let parsed = moonlight.lunast.parseScript(id, `(${moduleString})`);

     

       154
       154
       +
           if (parsed != null) {

     

       155
       155
       +
             // parseScript adds an extra ; for some reason

     

       156
       156
       +
             parsed = parsed.trimEnd().substring(0, parsed.lastIndexOf(";"));

     

       157
       157
       +
             if (patchModule(id, "lunast", parsed)) {

     

       158
       158
       +
               moduleString = parsed;

     

       146
       159
        
             }

     

       147
       160
        
           }

     

       148
       161

+1 -1

packages/lunast/TODO.md

···

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

     

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

     

       5
       5
        
       - [ ] Map Z/ZP to default

     

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

     

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

     

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

     

       8
       8
        
       - [ ] Support patching in the AST

     

       9
       9
        
         - 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

+16 -6

packages/lunast/src/index.ts

···

       3
       3
        
       import { getProcessors } from "./utils";

     

       4
       4
        
       import { parse } from "meriyah";

     

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

     

       6
       6
       +
       import { generate } from "astring";

     

       6
       7
        
       

     

       7
       8
        
       export default class LunAST {

     

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

     
···

       33
       34
        
           return "dev";

     

       34
       35
        
         }

     

       35
       36
        
       

     

       36
       36
       -
         public parseScript(id: string, code: string) {

     

       37
       37
       -
           const moduleString = code.toString().replace(/\n/g, "");

     

       37
       37
       +
         public parseScript(id: string, code: string): string | null {

     

       38
       38
        
           const available = [...this.processors]

     

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

     

       40
       40
        
             .filter((x) =>

     

       41
       41
        
               x.find != null

     

       42
       42
        
                 ? typeof x.find === "string"

     

       43
       43
       -
                   ? moduleString.indexOf(x.find) !== -1

     

       44
       44
       -
                   : x.find.test(moduleString)

     

       43
       43
       +
                   ? code.indexOf(x.find) !== -1

     

       44
       44
       +
                   : x.find.test(code)

     

       45
       45
        
                 : true

     

       46
       46
        
             )

     

       47
       47
        
             .filter((x) =>

     
···

       49
       49
        
                 ? x.dependencies.every((dep) => this.successful.has(dep))

     

       50
       50
        
                 : true

     

       51
       51
        
             );

     

       52
       52
       -
           if (available.length === 0) return;

     

       52
       52
       +
           if (available.length === 0) return null;

     

       53
       53
        
       

     

       54
       54
        
           const module = parse(code);

     

       55
       55
       +
           let dirty = false;

     

       55
       56
        
           const state: ProcessorState = {

     

       56
       57
        
             id,

     

       57
       58
        
             // @ts-expect-error The ESTree types are mismatched with estree-toolkit, but ESTree is a standard so this is fine

     

       58
       59
        
             ast: module,

     

       59
       59
       -
             lunast: this

     

       60
       60
       +
             lunast: this,

     

       61
       61
       +
             markDirty: () => {

     

       62
       62
       +
               dirty = true;

     

       63
       63
       +
             }

     

       60
       64
        
           };

     

       61
       65
        
       

     

       62
       66
        
           for (const processor of available) {

     
···

       64
       68
        
               this.processors.splice(this.processors.indexOf(processor), 1);

     

       65
       69
        
               this.successful.add(processor.name);

     

       66
       70
        
             }

     

       71
       71
       +
           }

     

       72
       72
       +
       

     

       73
       73
       +
           if (dirty) {

     

       74
       74
       +
             return generate(module);

     

       75
       75
       +
           } else {

     

       76
       76
       +
             return null;

     

       67
       77
        
           }

     

       68
       78
        
         }

     

       69
       79

+38 -2

packages/lunast/src/modules/test.ts

···

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

     

       2
       2
       -
       import { getExports, getGetters, register } from "../utils";

     

       2
       2
       +
       import { getExports, getPropertyGetters, register, magicAST } from "../utils";

     

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

     

       3
       4
        
       

     

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

     

       5
       6
        
       register({

     
···

       13
       14
        
         }

     

       14
       15
        
       });

     

       15
       16
        
       

     

       17
       17
       +
       // Exports example

     

       18
       18
       +
       /*register({

     

       19
       19
       +
         name: "ApplicationStoreDirectoryStore",

     

       20
       20
       +
         find: '"displayName","ApplicationStoreDirectoryStore"',

     

       21
       21
       +
         process({ ast }) {

     

       22
       22
       +
           const exports = getExports(ast);

     

       23
       23
       +
           return Object.keys(exports).length > 0;

     

       24
       24
       +
         }

     

       25
       25
       +
       });*/

     

       26
       26
       +
       

     

       27
       27
       +
       // Patching example

     

       28
       28
       +
       register({

     

       29
       29
       +
         name: "ImagePreview",

     

       30
       30
       +
         find: ".Messages.OPEN_IN_BROWSER",

     

       31
       31
       +
         process({ id, ast, lunast, markDirty }) {

     

       32
       32
       +
           const getters = getPropertyGetters(ast);

     

       33
       33
       +
           const replacement = magicAST(`return require("common_react").createElement(

     

       34
       34
       +
         "div",

     

       35
       35
       +
         {

     

       36
       36
       +
           style: {

     

       37
       37
       +
             color: "white",

     

       38
       38
       +
           },

     

       39
       39
       +
         },

     

       40
       40
       +
         "balls"

     

       41
       41
       +
       )`)!;

     

       42
       42
       +
           for (const node of Object.values(getters)) {

     

       43
       43
       +
             const body = node.path.get<BlockStatement>("body");

     

       44
       44
       +
             body.replaceWith(replacement);

     

       45
       45
       +
           }

     

       46
       46
       +
           markDirty();

     

       47
       47
       +
       

     

       48
       48
       +
           return true;

     

       49
       49
       +
         }

     

       50
       50
       +
       });

     

       51
       51
       +
       

     

       16
       52
        
       register({

     

       17
       53
        
         name: "ClipboardUtils",

     

       18
       54
        
         find: 'document.queryCommandEnabled("copy")',

     

       19
       55
        
         process({ id, ast, lunast }) {

     

       20
       20
       -
           const getters = getGetters(ast);

     

       56
       56
       +
           const getters = getPropertyGetters(ast);

     

       21
       57
        
           const fields = [];

     

       22
       58
        
       

     

       23
       59
        
           for (const [name, node] of Object.entries(getters)) {

packages/lunast/src/remap.ts

···

       12
       12
        
         id: string;

     

       13
       13
        
         ast: Program;

     

       14
       14
        
         lunast: LunAST;

     

       15
       15
       +
         markDirty: () => void;

     

       15
       16
        
       };

+62 -43

packages/lunast/src/utils.ts

···

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

     

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

     

       4
       4
        
       import type {

     

       5
       5
       +
         ExpressionStatement,

     

       5
       6
        
         ObjectExpression,

     

       6
       7
        
         Program,

     

       7
       8
        
         Property,

     

       8
       9
        
         ReturnStatement

     

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

     

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

     

       10
       12
        
       

     

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

     

       12
       14
        
       

     
···

       24
       26
        
       

     

       25
       27
        
         traverse(ast, {

     

       26
       28
        
           $: { scope: true },

     

       27
       27
       -
           BlockStatement: {

     

       28
       28
       -
             enter(path) {

     

       29
       29
       -
               // Walk up to make sure we are indeed the top level

     

       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
       -
                   this.stop();

     

       44
       44
       -
                   return;

     

       45
       45
       -
                 }

     

       29
       29
       +
           BlockStatement(path) {

     

       30
       30
       +
             // Walk up to make sure we are indeed the top level

     

       31
       31
       +
             let parent = path.parentPath;

     

       32
       32
       +
             while (!is.program(parent)) {

     

       33
       33
       +
               parent = parent?.parentPath ?? null;

     

       34
       34
       +
               if (

     

       35
       35
       +
                 parent == null ||

     

       36
       36
       +
                 parent.node == null ||

     

       37
       37
       +
                 ![

     

       38
       38
       +
                   "FunctionExpression",

     

       39
       39
       +
                   "ExpressionStatement",

     

       40
       40
       +
                   "CallExpression",

     

       41
       41
       +
                   "Program"

     

       42
       42
       +
                 ].includes(parent.node.type)

     

       43
       43
       +
               ) {

     

       44
       44
       +
                 return;

     

       46
       45
        
               }

     

       47
       47
       -
             },

     

       46
       46
       +
             }

     

       48
       47
        
       

     

       49
       49
       -
             leave(path) {

     

       50
       50
       -
               path.scope?.crawl();

     

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

     

       48
       48
       +
             if (!is.functionExpression(path.parent)) return;

     

       49
       49
       +
       

     

       50
       50
       +
             for (let i = 0; i < path.parent.params.length; i++) {

     

       51
       51
       +
               const param = path.parent.params[i];

     

       52
       52
       +
               if (!is.identifier(param)) continue;

     

       53
       53
       +
               const binding = path.scope?.getBinding(param.name);

     

       54
       54
       +
               if (!binding) continue;

     

       52
       55
        
       

     

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

     

       54
       54
       -
                 const param = path.parent.params[i];

     

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

     

       56
       56
       -
                 const binding = path.scope?.getBinding(param.name);

     

       57
       57
       -
                 if (!binding) continue;

     

       56
       56
       +
               // module

     

       57
       57
       +
               if (i === 0) {

     

       58
       58
       +
                 for (const reference of binding.references) {

     

       59
       59
       +
                   if (!is.identifier(reference.node)) continue;

     

       60
       60
       +
                   if (!is.assignmentExpression(reference.parentPath?.parentPath))

     

       61
       61
       +
                     continue;

     

       58
       62
        
       

     

       59
       59
       -
                 // module

     

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

     

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

     

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

     

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

     

       64
       64
       -
                       continue;

     

       63
       63
       +
                   const exportsNode = reference.parentPath?.parentPath.node;

     

       64
       64
       +
                   if (!is.memberExpression(exportsNode?.left)) continue;

     

       65
       65
       +
                   if (!is.identifier(exportsNode.left.property)) continue;

     

       66
       66
       +
                   if (exportsNode.left.property.name !== "exports") continue;

     

       65
       67
        
       

     

       66
       66
       -
                     const exports = reference.parentPath?.parentPath.node?.right;

     

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

     

       68
       68
       +
                   const exports = exportsNode?.right;

     

       69
       69
       +
                   if (!is.objectExpression(exports)) continue;

     

       68
       70
        
       

     

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

     

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

     

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

     

       72
       72
       -
                       ret[property.key.name] = property.value;

     

       73
       73
       -
                     }

     

       71
       71
       +
                   for (const property of exports.properties) {

     

       72
       72
       +
                     if (!is.property(property)) continue;

     

       73
       73
       +
                     if (!is.identifier(property.key)) continue;

     

       74
       74
       +
                     ret[property.key.name] = property.value;

     

       74
       75
        
                   }

     

       75
       76
        
                 }

     

       76
       76
       -
                 // TODO: exports

     

       77
       77
       +
               }

     

       78
       78
       +
               // TODO: exports

     

       79
       79
       +
               else if (i === 1) {

     

       80
       80
       +
                 // console.log("getExports:", path, param, binding);

     

       77
       81
        
               }

     

       78
       82
        
             }

     

       79
       83
        
           }

     
···

       82
       86
        
         return ret;

     

       83
       87
        
       }

     

       84
       88
        
       

     

       85
       85
       -
       export function getGetters(ast: Program) {

     

       89
       89
       +
       export function getPropertyGetters(ast: Program) {

     

       86
       90
        
         const ret: Record<string, Binding> = {};

     

       87
       91
        
       

     

       88
       92
        
         traverse(ast, {

     
···

       124
       128
        
       

     

       125
       129
        
         return ret;

     

       126
       130
        
       }

     

       131
       131
       +
       

     

       132
       132
       +
       export function magicAST(code: string) {

     

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

     

       134
       134
       +
         // Might not work for some other syntax issues but oh well

     

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

     

       136
       136
       +
       

     

       137
       137
       +
         const expressionStatement = tree.body[0] as ExpressionStatement;

     

       138
       138
       +
         if (!is.expressionStatement(expressionStatement)) return null;

     

       139
       139
       +
         if (!is.callExpression(expressionStatement.expression)) return null;

     

       140
       140
       +
         if (!is.arrowFunctionExpression(expressionStatement.expression.callee))

     

       141
       141
       +
           return null;

     

       142
       142
       +
         if (!is.blockStatement(expressionStatement.expression.callee.body))

     

       143
       143
       +
           return null;

     

       144
       144
       +
         return expressionStatement.expression.callee.body;

     

       145
       145
       +
       }

+1 -1

tsconfig.json

···

       1
       1
        
       {

     

       2
       2
        
         "compilerOptions": {

     

       3
       3
       -
           "target": "es2016",

     

       3
       3
       +
           "target": "es2022",

     

       4
       4
        
           "module": "es6",

     

       5
       5
        
           "esModuleInterop": true,

     

       6
       6
        
           "forceConsistentCasingInFileNames": true,