···

       
144
       
 
       
    }

     

       
145
       
 
       
    for (const [, , id] of state.info.componentStack.matchAll(MODULE_REGEX))

     

       
146
       
 
       
      for (const ext of moonlight.patched.get(id) ?? []) causes.add(ext);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
147
       
 
       
    return [...causes];

     

       
148
       
 
       
  }, []);

     

       
149
       
 
       


     

···

       
144
       
 
       
    }

     

       
145
       
 
       
    for (const [, , id] of state.info.componentStack.matchAll(MODULE_REGEX))

     

       
146
       
 
       
      for (const ext of moonlight.patched.get(id) ?? []) causes.add(ext);

     

       
147
       
+
       


     

       
148
       
+
       
    for (const [path, id] of Object.entries(moonlight.moonmap.modules)) {

     

       
149
       
+
       
      const MAPPING_REGEX = new RegExp(

     

       
150
       
+
       
        // @ts-expect-error Only Firefox has RegExp.escape

     

       
151
       
+
       
        `(${RegExp.escape ? RegExp.escape(path) : path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})`

     

       
152
       
+
       
      );

     

       
153
       
+
       


     

       
154
       
+
       
      if (state.error.stack) {

     

       
155
       
+
       
        for (const match of state.error.stack.matchAll(MAPPING_REGEX))

     

       
156
       
+
       
          if (match) for (const ext of moonlight.patched.get(id) ?? []) causes.add(ext);

     

       
157
       
+
       
      }

     

       
158
       
+
       
      for (const match of state.info.componentStack.matchAll(MAPPING_REGEX))

     

       
159
       
+
       
        if (match) for (const ext of moonlight.patched.get(id) ?? []) causes.add(ext);

     

       
160
       
+
       
    }

     

       
161
       
+
       


     

       
162
       
 
       
    return [...causes];

     

       
163
       
 
       
  }, []);

     

       
164
       
 
       


     

···

       
66
       
 
       
const moduleCache: Record<string, string> = {};

     

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

     

       
68
       
 
       


     

       
69
       
-
       
function patchModules(entry: WebpackJsonpEntry[1]) {

     

       
70
       
-
       
  function patchModule(id: string, patchId: string, replaced: string) {

     

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

     

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

     

       
73
       
-
       
    patched[id].push(patchId);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
74
       
 
       


     

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

     

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

     

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

     

       
78
       
 
       


     

       
79
       
-
       
    const wrapped =

     

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

     

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

     

       
82
       
-
       
      `//# sourceURL=Webpack-Module/${id.slice(0, 3)}/${id}`;

     

       
83
       
 
       


     

       
84
       
-
       
    try {

     

       
85
       
-
       
      const func = new Function("module", "exports", "require", wrapped) as WebpackModuleFunc;

     

       
86
       
-
       
      entry[id] = func;

     

       
87
       
-
       
      entry[id].__moonlight = true;

     

       
88
       
-
       
      return true;

     

       
89
       
-
       
    } catch (e) {

     

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

     

       
91
       
-
       
      patched[id].pop();

     

       
92
       
-
       
      return false;

     

       
93
       
-
       
    }

     

       
94
       
 
       
  }

     

       
0
       
 
       

     

       
95
       
 
       


     

       
0
       
 
       

     

       
96
       
 
       
  // Populate the module cache

     

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

     

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

     
···

       
185
       
 
       
    }

     

       
186
       
 
       


     

       
187
       
 
       
    if (modified) {

     

       
188
       
-
       
      if (!swappedModule) patchModule(id, patchedStr.join(", "), moduleString);

     

       
189
       
 
       
      moduleCache[id] = moduleString;

     

       
190
       
 
       
      moonlight.patched.set(id, exts);

     

       
191
       
 
       
    }

     
···

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

     

       
195
       
 
       
      if (parsed != null) {

     

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

     

       
197
       
-
       
          if (patchModule(parsedId, "lunast", parsedScript)) {

     

       
198
       
 
       
            moduleCache[parsedId] = parsedScript;

     

       
199
       
 
       
          }

     

       
200
       
 
       
        }

     
···

       
205
       
 
       


     

       
206
       
 
       
    if (moonlightNode.config.patchAll === true) {

     

       
207
       
 
       
      if ((typeof id !== "string" || !id.includes("_")) && !entry[id].__moonlight) {

     

       
208
       
-
       
        const wrapped =

     

       
209
       
-
       
          `(${moduleCache[id]}).apply(this, arguments)\n` + `//# sourceURL=Webpack-Module/${id.slice(0, 3)}/${id}`;

     

       
210
       
 
       
        entry[id] = new Function("module", "exports", "require", wrapped) as WebpackModuleFunc;

     

       
211
       
 
       
        entry[id].__moonlight = true;

     

       
212
       
 
       
      }

     
···

       
329
       
 
       
  }

     

       
330
       
 
       


     

       
331
       
 
       
  for (const [name, func] of Object.entries(moonlight.moonmap.getWebpackModules("window.moonlight.moonmap"))) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
332
       
 
       
    injectedWpModules.push({ id: name, run: func });

     

       
333
       
 
       
    modules[name] = func;

     

       
334
       
 
       
    inject = true;

     

···

       
66
       
 
       
const moduleCache: Record<string, string> = {};

     

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

     

       
68
       
 
       


     

       
69
       
+
       
function createSourceURL(id: string) {

     

       
70
       
+
       
  const remapped = Object.entries(moonlight.moonmap.modules).find((m) => m[1] === id)?.[0];

     

       
71
       
+
       


     

       
72
       
+
       
  if (remapped) {

     

       
73
       
+
       
    return `// Webpack Module: ${id}\n//# sourceURL=${remapped}`;

     

       
74
       
+
       
  }

     

       
75
       
+
       


     

       
76
       
+
       
  return `//# sourceURL=Webpack-Module/${id.slice(0, 3)}/${id}`;

     

       
77
       
+
       
}

     

       
78
       
+
       


     

       
79
       
+
       
function patchModule(id: string, patchId: string, replaced: string, entry: WebpackJsonpEntry[1]) {

     

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

     

       
81
       
+
       
  patched[id] = patched[id] ?? [];

     

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

     

       
83
       
 
       


     

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

     

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

     

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

     

       
87
       
 
       


     

       
88
       
+
       
  const wrapped =

     

       
89
       
+
       
    `(${replaced}).apply(this, arguments)\n` + `// Patched by moonlight: ${patchedStr}\n` + createSourceURL(id);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
90
       
 
       


     

       
91
       
+
       
  try {

     

       
92
       
+
       
    const func = new Function("module", "exports", "require", wrapped) as WebpackModuleFunc;

     

       
93
       
+
       
    entry[id] = func;

     

       
94
       
+
       
    entry[id].__moonlight = true;

     

       
95
       
+
       
    return true;

     

       
96
       
+
       
  } catch (e) {

     

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

     

       
98
       
+
       
    patched[id].pop();

     

       
99
       
+
       
    return false;

     

       
0
       
 
       

     

       
100
       
 
       
  }

     

       
101
       
+
       
}

     

       
102
       
 
       


     

       
103
       
+
       
function patchModules(entry: WebpackJsonpEntry[1]) {

     

       
104
       
 
       
  // Populate the module cache

     

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

     

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

     
···

       
193
       
 
       
    }

     

       
194
       
 
       


     

       
195
       
 
       
    if (modified) {

     

       
196
       
+
       
      if (!swappedModule) patchModule(id, patchedStr.join(", "), moduleString, entry);

     

       
197
       
 
       
      moduleCache[id] = moduleString;

     

       
198
       
 
       
      moonlight.patched.set(id, exts);

     

       
199
       
 
       
    }

     
···

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

     

       
203
       
 
       
      if (parsed != null) {

     

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

     

       
205
       
+
       
          if (patchModule(parsedId, "lunast", parsedScript, entry)) {

     

       
206
       
 
       
            moduleCache[parsedId] = parsedScript;

     

       
207
       
 
       
          }

     

       
208
       
 
       
        }

     
···

       
213
       
 
       


     

       
214
       
 
       
    if (moonlightNode.config.patchAll === true) {

     

       
215
       
 
       
      if ((typeof id !== "string" || !id.includes("_")) && !entry[id].__moonlight) {

     

       
216
       
+
       
        const wrapped = `(${moduleCache[id]}).apply(this, arguments)\n` + createSourceURL(id);

     

       
0
       
 
       

     

       
217
       
 
       
        entry[id] = new Function("module", "exports", "require", wrapped) as WebpackModuleFunc;

     

       
218
       
 
       
        entry[id].__moonlight = true;

     

       
219
       
 
       
      }

     
···

       
336
       
 
       
  }

     

       
337
       
 
       


     

       
338
       
 
       
  for (const [name, func] of Object.entries(moonlight.moonmap.getWebpackModules("window.moonlight.moonmap"))) {

     

       
339
       
+
       
    // @ts-expect-error probably should fix the type on this idk

     

       
340
       
+
       
    func.__moonlight = true;

     

       
341
       
 
       
    injectedWpModules.push({ id: name, run: func });

     

       
342
       
 
       
    modules[name] = func;

     

       
343
       
 
       
    inject = true;