···

       
60
       
 
       
      let idx = 0;

     

       
61
       
 
       
      for (const patch of exports.patches) {

     

       
62
       
 
       
        if (Array.isArray(patch.replace)) {

     

       
63
       
-
       
          for (const replacement of patch.replace) {

     

       
64
       
-
       
            const newPatch = Object.assign({}, patch, {

     

       
65
       
-
       
              replace: replacement

     

       
66
       
-
       
            });

     

       
67
       
-
       


     

       
68
       
-
       
            registerPatch({ ...newPatch, ext: ext.id, id: idx });

     

       
69
       
-
       
            idx++;

     

       
70
       
-
       
          }

     

       
71
       
 
       
        } else {

     

       
72
       
-
       
          registerPatch({ ...patch, ext: ext.id, id: idx });

     

       
73
       
-
       
          idx++;

     

       
74
       
 
       
        }

     

       
0
       
 
       

     

       
75
       
 
       
      }

     

       
76
       
 
       
    }

     

       
77
       
 
       


     

···

       
60
       
 
       
      let idx = 0;

     

       
61
       
 
       
      for (const patch of exports.patches) {

     

       
62
       
 
       
        if (Array.isArray(patch.replace)) {

     

       
63
       
+
       
          registerPatch({ ...patch, ext: ext.id, id: idx });

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
64
       
 
       
        } else {

     

       
65
       
+
       
          registerPatch({ ...patch, replace: [patch.replace], ext: ext.id, id: idx });

     

       
0
       
 
       

     

       
66
       
 
       
        }

     

       
67
       
+
       
        idx++;

     

       
68
       
 
       
      }

     

       
69
       
 
       
    }

     

       
70
       
 
       


     

···

       
103
       
 
       


     

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

     

       
105
       
 
       
    if (func.__moonlight === true) continue;

     

       
106
       
-
       
    let moduleString = moduleCache[id];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
107
       
 
       


     

       
108
       
 
       
    for (let i = 0; i < patches.length; i++) {

     

       
109
       
 
       
      const patch = patches[i];

     
···

       
116
       
 
       
        patch.find.lastIndex = 0;

     

       
117
       
 
       
      }

     

       
118
       
 
       


     

       
119
       
-
       
      const match = testFind(moduleString, patch.find);

     

       
120
       
 
       


     

       
121
       
 
       
      // Global regexes apply to all modules

     

       
122
       
 
       
      const shouldRemove = typeof patch.find === "string" ? true : !patch.find.global;

     

       
123
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
124
       
 
       
      if (match) {

     

       
125
       
-
       
        // We ensured all arrays get turned into normal PatchReplace objects on register

     

       
126
       
-
       
        const replace = patch.replace as PatchReplace;

     

       
127
       
 
       


     

       
128
       
-
       
        if (replace.type === undefined || replace.type === PatchReplaceType.Normal) {

     

       
129
       
-
       
          // tsc fails to detect the overloads for this, so I'll just do this

     

       
130
       
-
       
          // Verbose, but it works

     

       
131
       
-
       
          let replaced;

     

       
132
       
-
       
          if (typeof replace.replacement === "string") {

     

       
133
       
-
       
            replaced = moduleString.replace(replace.match, replace.replacement);

     

       
134
       
-
       
          } else {

     

       
135
       
-
       
            replaced = moduleString.replace(replace.match, replace.replacement);

     

       
136
       
-
       
          }

     

       
137
       
 
       


     

       
138
       
-
       
          if (replaced === moduleString) {

     

       
139
       
-
       
            logger.warn("Patch replacement failed", id, patch);

     

       
140
       
-
       
            continue;

     

       
141
       
-
       
          }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
142
       
 
       


     

       
143
       
-
       
          if (patchModule(id, `${patch.ext}#${patch.id}`, replaced)) {

     

       
144
       
-
       
            moduleString = replaced;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
145
       
 
       
          }

     

       
146
       
-
       
        } else if (replace.type === PatchReplaceType.Module) {

     

       
147
       
-
       
          // Directly replace the module with a new one

     

       
148
       
-
       
          const newModule = replace.replacement(moduleString);

     

       
149
       
-
       
          entry[id] = newModule;

     

       
150
       
-
       
          entry[id].__moonlight = true;

     

       
151
       
-
       
          moduleString = newModule.toString().replace(/\n/g, "") + `//# sourceURL=Webpack-Module-${id}`;

     

       
152
       
 
       
        }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
153
       
 
       


     

       
154
       
 
       
        moonlight.unpatched.delete(patch);

     

       
155
       
-
       


     

       
156
       
-
       
        if (shouldRemove) {

     

       
157
       
-
       
          patches.splice(i--, 1);

     

       
158
       
-
       
        }

     

       
159
       
 
       
      }

     

       
160
       
 
       
    }

     

       
161
       
 
       


     

       
0
       
 
       

     

       
162
       
 
       
    moduleCache[id] = moduleString;

     

       
163
       
 
       


     

       
164
       
 
       
    try {

     

···

       
103
       
 
       


     

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

     

       
105
       
 
       
    if (func.__moonlight === true) continue;

     

       
106
       
+
       


     

       
107
       
+
       
    // Clone the module string so finds don't get messed up by other extensions

     

       
108
       
+
       
    const origModuleString = moduleCache[id];

     

       
109
       
+
       
    let moduleString = origModuleString;

     

       
110
       
+
       
    const patchedStr = [];

     

       
111
       
+
       
    const mappedName = moonlight.moonmap.modules[id];

     

       
112
       
 
       


     

       
113
       
 
       
    for (let i = 0; i < patches.length; i++) {

     

       
114
       
 
       
      const patch = patches[i];

     
···

       
121
       
 
       
        patch.find.lastIndex = 0;

     

       
122
       
 
       
      }

     

       
123
       
 
       


     

       
124
       
+
       
      const match = testFind(origModuleString, patch.find) || patch.find === mappedName;

     

       
125
       
 
       


     

       
126
       
 
       
      // Global regexes apply to all modules

     

       
127
       
 
       
      const shouldRemove = typeof patch.find === "string" ? true : !patch.find.global;

     

       
128
       
 
       


     

       
129
       
+
       
      let replaced = moduleString;

     

       
130
       
+
       
      let hardFailed = false;

     

       
131
       
 
       
      if (match) {

     

       
132
       
+
       
        // We ensured normal PatchReplace objects get turned into arrays on register

     

       
133
       
+
       
        const replaces = patch.replace as PatchReplace[];

     

       
134
       
 
       


     

       
135
       
+
       
        for (let i = 0; i < replaces.length; i++) {

     

       
136
       
+
       
          const replace = replaces[i];

     

       
137
       
+
       
          let patchId = `${patch.ext}#${patch.id}`;

     

       
138
       
+
       
          if (replaces.length > 1) patchId += `#${i}`;

     

       
139
       
+
       
          patchedStr.push(patchId);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
140
       
 
       


     

       
141
       
+
       
          if (replace.type === undefined || replace.type === PatchReplaceType.Normal) {

     

       
142
       
+
       
            // tsc fails to detect the overloads for this, so I'll just do this

     

       
143
       
+
       
            // Verbose, but it works

     

       
144
       
+
       
            if (typeof replace.replacement === "string") {

     

       
145
       
+
       
              replaced = replaced.replace(replace.match, replace.replacement);

     

       
146
       
+
       
            } else {

     

       
147
       
+
       
              replaced = replaced.replace(replace.match, replace.replacement);

     

       
148
       
+
       
            }

     

       
149
       
 
       


     

       
150
       
+
       
            if (replaced === moduleString) {

     

       
151
       
+
       
              logger.warn("Patch replacement failed", id, patch);

     

       
152
       
+
       
              if (patch.hardFail) {

     

       
153
       
+
       
                hardFailed = true;

     

       
154
       
+
       
                break;

     

       
155
       
+
       
              } else {

     

       
156
       
+
       
                continue;

     

       
157
       
+
       
              }

     

       
158
       
+
       
            }

     

       
159
       
+
       
          } else if (replace.type === PatchReplaceType.Module) {

     

       
160
       
+
       
            // Directly replace the module with a new one

     

       
161
       
+
       
            const newModule = replace.replacement(replaced);

     

       
162
       
+
       
            entry[id] = newModule;

     

       
163
       
+
       
            entry[id].__moonlight = true;

     

       
164
       
+
       
            replaced = replaced.toString().replace(/\n/g, "") + `//# sourceURL=Webpack-Module-${id}`;

     

       
165
       
 
       
          }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
166
       
 
       
        }

     

       
167
       
+
       


     

       
168
       
+
       
        if (!hardFailed) moduleString = replaced;

     

       
169
       
 
       


     

       
170
       
 
       
        moonlight.unpatched.delete(patch);

     

       
171
       
+
       
        if (shouldRemove) patches.splice(i--, 1);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
172
       
 
       
      }

     

       
173
       
 
       
    }

     

       
174
       
 
       


     

       
175
       
+
       
    patchModule(id, patchedStr.join(", "), moduleString);

     

       
176
       
 
       
    moduleCache[id] = moduleString;

     

       
177
       
 
       


     

       
178
       
 
       
    try {

     

···

       
108
       
 
       
export type Patch = {

     

       
109
       
 
       
  find: PatchMatch;

     

       
110
       
 
       
  replace: PatchReplace | PatchReplace[];

     

       
0
       
 
       

     

       
111
       
 
       
  prerequisite?: () => boolean;

     

       
112
       
 
       
};

     

       
113
       
 
       


     

···

       
108
       
 
       
export type Patch = {

     

       
109
       
 
       
  find: PatchMatch;

     

       
110
       
 
       
  replace: PatchReplace | PatchReplace[];

     

       
111
       
+
       
  hardFail?: boolean; // if any patches fail, all fail

     

       
112
       
 
       
  prerequisite?: () => boolean;

     

       
113
       
 
       
};

     

       
114