@prisma/client-generator-ts 6.12.0-dev.32 → 6.12.0-dev.34

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. package/dist/generateClient.d.ts +3 -1
  2. package/dist/index.d.mts +2 -0
  3. package/dist/index.d.ts +2 -0
  4. package/dist/index.js +444 -395
  5. package/dist/index.mjs +452 -403
  6. package/dist/utils/addPreamble.d.ts +1 -1
  7. package/dist/utils/{buildGetWasmModule.d.ts → wasm.d.ts} +6 -12
  8. package/package.json +9 -9
package/dist/index.mjs CHANGED
@@ -85,54 +85,54 @@ var require_polyfills = __commonJS({
85
85
  }
86
86
  var chdir;
87
87
  module.exports = patch;
88
- function patch(fs2) {
88
+ function patch(fs3) {
89
89
  if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
90
- patchLchmod(fs2);
91
- }
92
- if (!fs2.lutimes) {
93
- patchLutimes(fs2);
94
- }
95
- fs2.chown = chownFix(fs2.chown);
96
- fs2.fchown = chownFix(fs2.fchown);
97
- fs2.lchown = chownFix(fs2.lchown);
98
- fs2.chmod = chmodFix(fs2.chmod);
99
- fs2.fchmod = chmodFix(fs2.fchmod);
100
- fs2.lchmod = chmodFix(fs2.lchmod);
101
- fs2.chownSync = chownFixSync(fs2.chownSync);
102
- fs2.fchownSync = chownFixSync(fs2.fchownSync);
103
- fs2.lchownSync = chownFixSync(fs2.lchownSync);
104
- fs2.chmodSync = chmodFixSync(fs2.chmodSync);
105
- fs2.fchmodSync = chmodFixSync(fs2.fchmodSync);
106
- fs2.lchmodSync = chmodFixSync(fs2.lchmodSync);
107
- fs2.stat = statFix(fs2.stat);
108
- fs2.fstat = statFix(fs2.fstat);
109
- fs2.lstat = statFix(fs2.lstat);
110
- fs2.statSync = statFixSync(fs2.statSync);
111
- fs2.fstatSync = statFixSync(fs2.fstatSync);
112
- fs2.lstatSync = statFixSync(fs2.lstatSync);
113
- if (fs2.chmod && !fs2.lchmod) {
114
- fs2.lchmod = function(path5, mode, cb) {
90
+ patchLchmod(fs3);
91
+ }
92
+ if (!fs3.lutimes) {
93
+ patchLutimes(fs3);
94
+ }
95
+ fs3.chown = chownFix(fs3.chown);
96
+ fs3.fchown = chownFix(fs3.fchown);
97
+ fs3.lchown = chownFix(fs3.lchown);
98
+ fs3.chmod = chmodFix(fs3.chmod);
99
+ fs3.fchmod = chmodFix(fs3.fchmod);
100
+ fs3.lchmod = chmodFix(fs3.lchmod);
101
+ fs3.chownSync = chownFixSync(fs3.chownSync);
102
+ fs3.fchownSync = chownFixSync(fs3.fchownSync);
103
+ fs3.lchownSync = chownFixSync(fs3.lchownSync);
104
+ fs3.chmodSync = chmodFixSync(fs3.chmodSync);
105
+ fs3.fchmodSync = chmodFixSync(fs3.fchmodSync);
106
+ fs3.lchmodSync = chmodFixSync(fs3.lchmodSync);
107
+ fs3.stat = statFix(fs3.stat);
108
+ fs3.fstat = statFix(fs3.fstat);
109
+ fs3.lstat = statFix(fs3.lstat);
110
+ fs3.statSync = statFixSync(fs3.statSync);
111
+ fs3.fstatSync = statFixSync(fs3.fstatSync);
112
+ fs3.lstatSync = statFixSync(fs3.lstatSync);
113
+ if (fs3.chmod && !fs3.lchmod) {
114
+ fs3.lchmod = function(path6, mode, cb) {
115
115
  if (cb) process.nextTick(cb);
116
116
  };
117
- fs2.lchmodSync = function() {
117
+ fs3.lchmodSync = function() {
118
118
  };
119
119
  }
120
- if (fs2.chown && !fs2.lchown) {
121
- fs2.lchown = function(path5, uid, gid, cb) {
120
+ if (fs3.chown && !fs3.lchown) {
121
+ fs3.lchown = function(path6, uid, gid, cb) {
122
122
  if (cb) process.nextTick(cb);
123
123
  };
124
- fs2.lchownSync = function() {
124
+ fs3.lchownSync = function() {
125
125
  };
126
126
  }
127
127
  if (platform === "win32") {
128
- fs2.rename = typeof fs2.rename !== "function" ? fs2.rename : function(fs$rename) {
128
+ fs3.rename = typeof fs3.rename !== "function" ? fs3.rename : function(fs$rename) {
129
129
  function rename(from, to, cb) {
130
130
  var start = Date.now();
131
131
  var backoff = 0;
132
132
  fs$rename(from, to, function CB(er) {
133
133
  if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
134
134
  setTimeout(function() {
135
- fs2.stat(to, function(stater, st) {
135
+ fs3.stat(to, function(stater, st) {
136
136
  if (stater && stater.code === "ENOENT")
137
137
  fs$rename(from, to, CB);
138
138
  else
@@ -148,9 +148,9 @@ var require_polyfills = __commonJS({
148
148
  }
149
149
  if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
150
150
  return rename;
151
- }(fs2.rename);
151
+ }(fs3.rename);
152
152
  }
153
- fs2.read = typeof fs2.read !== "function" ? fs2.read : function(fs$read) {
153
+ fs3.read = typeof fs3.read !== "function" ? fs3.read : function(fs$read) {
154
154
  function read(fd, buffer, offset, length, position, callback_) {
155
155
  var callback;
156
156
  if (callback_ && typeof callback_ === "function") {
@@ -158,22 +158,22 @@ var require_polyfills = __commonJS({
158
158
  callback = function(er, _, __) {
159
159
  if (er && er.code === "EAGAIN" && eagCounter < 10) {
160
160
  eagCounter++;
161
- return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
161
+ return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
162
162
  }
163
163
  callback_.apply(this, arguments);
164
164
  };
165
165
  }
166
- return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
166
+ return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
167
167
  }
168
168
  if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
169
169
  return read;
170
- }(fs2.read);
171
- fs2.readSync = typeof fs2.readSync !== "function" ? fs2.readSync : /* @__PURE__ */ function(fs$readSync) {
170
+ }(fs3.read);
171
+ fs3.readSync = typeof fs3.readSync !== "function" ? fs3.readSync : /* @__PURE__ */ function(fs$readSync) {
172
172
  return function(fd, buffer, offset, length, position) {
173
173
  var eagCounter = 0;
174
174
  while (true) {
175
175
  try {
176
- return fs$readSync.call(fs2, fd, buffer, offset, length, position);
176
+ return fs$readSync.call(fs3, fd, buffer, offset, length, position);
177
177
  } catch (er) {
178
178
  if (er.code === "EAGAIN" && eagCounter < 10) {
179
179
  eagCounter++;
@@ -183,11 +183,11 @@ var require_polyfills = __commonJS({
183
183
  }
184
184
  }
185
185
  };
186
- }(fs2.readSync);
187
- function patchLchmod(fs3) {
188
- fs3.lchmod = function(path5, mode, callback) {
189
- fs3.open(
190
- path5,
186
+ }(fs3.readSync);
187
+ function patchLchmod(fs4) {
188
+ fs4.lchmod = function(path6, mode, callback) {
189
+ fs4.open(
190
+ path6,
191
191
  constants.O_WRONLY | constants.O_SYMLINK,
192
192
  mode,
193
193
  function(err, fd) {
@@ -195,80 +195,80 @@ var require_polyfills = __commonJS({
195
195
  if (callback) callback(err);
196
196
  return;
197
197
  }
198
- fs3.fchmod(fd, mode, function(err2) {
199
- fs3.close(fd, function(err22) {
198
+ fs4.fchmod(fd, mode, function(err2) {
199
+ fs4.close(fd, function(err22) {
200
200
  if (callback) callback(err2 || err22);
201
201
  });
202
202
  });
203
203
  }
204
204
  );
205
205
  };
206
- fs3.lchmodSync = function(path5, mode) {
207
- var fd = fs3.openSync(path5, constants.O_WRONLY | constants.O_SYMLINK, mode);
206
+ fs4.lchmodSync = function(path6, mode) {
207
+ var fd = fs4.openSync(path6, constants.O_WRONLY | constants.O_SYMLINK, mode);
208
208
  var threw = true;
209
209
  var ret;
210
210
  try {
211
- ret = fs3.fchmodSync(fd, mode);
211
+ ret = fs4.fchmodSync(fd, mode);
212
212
  threw = false;
213
213
  } finally {
214
214
  if (threw) {
215
215
  try {
216
- fs3.closeSync(fd);
216
+ fs4.closeSync(fd);
217
217
  } catch (er) {
218
218
  }
219
219
  } else {
220
- fs3.closeSync(fd);
220
+ fs4.closeSync(fd);
221
221
  }
222
222
  }
223
223
  return ret;
224
224
  };
225
225
  }
226
- function patchLutimes(fs3) {
227
- if (constants.hasOwnProperty("O_SYMLINK") && fs3.futimes) {
228
- fs3.lutimes = function(path5, at, mt, cb) {
229
- fs3.open(path5, constants.O_SYMLINK, function(er, fd) {
226
+ function patchLutimes(fs4) {
227
+ if (constants.hasOwnProperty("O_SYMLINK") && fs4.futimes) {
228
+ fs4.lutimes = function(path6, at, mt, cb) {
229
+ fs4.open(path6, constants.O_SYMLINK, function(er, fd) {
230
230
  if (er) {
231
231
  if (cb) cb(er);
232
232
  return;
233
233
  }
234
- fs3.futimes(fd, at, mt, function(er2) {
235
- fs3.close(fd, function(er22) {
234
+ fs4.futimes(fd, at, mt, function(er2) {
235
+ fs4.close(fd, function(er22) {
236
236
  if (cb) cb(er2 || er22);
237
237
  });
238
238
  });
239
239
  });
240
240
  };
241
- fs3.lutimesSync = function(path5, at, mt) {
242
- var fd = fs3.openSync(path5, constants.O_SYMLINK);
241
+ fs4.lutimesSync = function(path6, at, mt) {
242
+ var fd = fs4.openSync(path6, constants.O_SYMLINK);
243
243
  var ret;
244
244
  var threw = true;
245
245
  try {
246
- ret = fs3.futimesSync(fd, at, mt);
246
+ ret = fs4.futimesSync(fd, at, mt);
247
247
  threw = false;
248
248
  } finally {
249
249
  if (threw) {
250
250
  try {
251
- fs3.closeSync(fd);
251
+ fs4.closeSync(fd);
252
252
  } catch (er) {
253
253
  }
254
254
  } else {
255
- fs3.closeSync(fd);
255
+ fs4.closeSync(fd);
256
256
  }
257
257
  }
258
258
  return ret;
259
259
  };
260
- } else if (fs3.futimes) {
261
- fs3.lutimes = function(_a, _b, _c, cb) {
260
+ } else if (fs4.futimes) {
261
+ fs4.lutimes = function(_a, _b, _c, cb) {
262
262
  if (cb) process.nextTick(cb);
263
263
  };
264
- fs3.lutimesSync = function() {
264
+ fs4.lutimesSync = function() {
265
265
  };
266
266
  }
267
267
  }
268
268
  function chmodFix(orig) {
269
269
  if (!orig) return orig;
270
270
  return function(target, mode, cb) {
271
- return orig.call(fs2, target, mode, function(er) {
271
+ return orig.call(fs3, target, mode, function(er) {
272
272
  if (chownErOk(er)) er = null;
273
273
  if (cb) cb.apply(this, arguments);
274
274
  });
@@ -278,7 +278,7 @@ var require_polyfills = __commonJS({
278
278
  if (!orig) return orig;
279
279
  return function(target, mode) {
280
280
  try {
281
- return orig.call(fs2, target, mode);
281
+ return orig.call(fs3, target, mode);
282
282
  } catch (er) {
283
283
  if (!chownErOk(er)) throw er;
284
284
  }
@@ -287,7 +287,7 @@ var require_polyfills = __commonJS({
287
287
  function chownFix(orig) {
288
288
  if (!orig) return orig;
289
289
  return function(target, uid, gid, cb) {
290
- return orig.call(fs2, target, uid, gid, function(er) {
290
+ return orig.call(fs3, target, uid, gid, function(er) {
291
291
  if (chownErOk(er)) er = null;
292
292
  if (cb) cb.apply(this, arguments);
293
293
  });
@@ -297,7 +297,7 @@ var require_polyfills = __commonJS({
297
297
  if (!orig) return orig;
298
298
  return function(target, uid, gid) {
299
299
  try {
300
- return orig.call(fs2, target, uid, gid);
300
+ return orig.call(fs3, target, uid, gid);
301
301
  } catch (er) {
302
302
  if (!chownErOk(er)) throw er;
303
303
  }
@@ -317,13 +317,13 @@ var require_polyfills = __commonJS({
317
317
  }
318
318
  if (cb) cb.apply(this, arguments);
319
319
  }
320
- return options ? orig.call(fs2, target, options, callback) : orig.call(fs2, target, callback);
320
+ return options ? orig.call(fs3, target, options, callback) : orig.call(fs3, target, callback);
321
321
  };
322
322
  }
323
323
  function statFixSync(orig) {
324
324
  if (!orig) return orig;
325
325
  return function(target, options) {
326
- var stats = options ? orig.call(fs2, target, options) : orig.call(fs2, target);
326
+ var stats = options ? orig.call(fs3, target, options) : orig.call(fs3, target);
327
327
  if (stats) {
328
328
  if (stats.uid < 0) stats.uid += 4294967296;
329
329
  if (stats.gid < 0) stats.gid += 4294967296;
@@ -353,16 +353,16 @@ var require_legacy_streams = __commonJS({
353
353
  "use strict";
354
354
  var Stream = __require("stream").Stream;
355
355
  module.exports = legacy;
356
- function legacy(fs2) {
356
+ function legacy(fs3) {
357
357
  return {
358
358
  ReadStream,
359
359
  WriteStream
360
360
  };
361
- function ReadStream(path5, options) {
362
- if (!(this instanceof ReadStream)) return new ReadStream(path5, options);
361
+ function ReadStream(path6, options) {
362
+ if (!(this instanceof ReadStream)) return new ReadStream(path6, options);
363
363
  Stream.call(this);
364
364
  var self = this;
365
- this.path = path5;
365
+ this.path = path6;
366
366
  this.fd = null;
367
367
  this.readable = true;
368
368
  this.paused = false;
@@ -396,7 +396,7 @@ var require_legacy_streams = __commonJS({
396
396
  });
397
397
  return;
398
398
  }
399
- fs2.open(this.path, this.flags, this.mode, function(err, fd) {
399
+ fs3.open(this.path, this.flags, this.mode, function(err, fd) {
400
400
  if (err) {
401
401
  self.emit("error", err);
402
402
  self.readable = false;
@@ -407,10 +407,10 @@ var require_legacy_streams = __commonJS({
407
407
  self._read();
408
408
  });
409
409
  }
410
- function WriteStream(path5, options) {
411
- if (!(this instanceof WriteStream)) return new WriteStream(path5, options);
410
+ function WriteStream(path6, options) {
411
+ if (!(this instanceof WriteStream)) return new WriteStream(path6, options);
412
412
  Stream.call(this);
413
- this.path = path5;
413
+ this.path = path6;
414
414
  this.fd = null;
415
415
  this.writable = true;
416
416
  this.flags = "w";
@@ -435,7 +435,7 @@ var require_legacy_streams = __commonJS({
435
435
  this.busy = false;
436
436
  this._queue = [];
437
437
  if (this.fd === null) {
438
- this._open = fs2.open;
438
+ this._open = fs3.open;
439
439
  this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
440
440
  this.flush();
441
441
  }
@@ -471,7 +471,7 @@ var require_clone = __commonJS({
471
471
  var require_graceful_fs = __commonJS({
472
472
  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports, module) {
473
473
  "use strict";
474
- var fs2 = __require("fs");
474
+ var fs3 = __require("fs");
475
475
  var polyfills = require_polyfills();
476
476
  var legacy = require_legacy_streams();
477
477
  var clone = require_clone();
@@ -503,12 +503,12 @@ var require_graceful_fs = __commonJS({
503
503
  m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
504
504
  console.error(m);
505
505
  };
506
- if (!fs2[gracefulQueue]) {
506
+ if (!fs3[gracefulQueue]) {
507
507
  queue = global[gracefulQueue] || [];
508
- publishQueue(fs2, queue);
509
- fs2.close = function(fs$close) {
508
+ publishQueue(fs3, queue);
509
+ fs3.close = function(fs$close) {
510
510
  function close(fd, cb) {
511
- return fs$close.call(fs2, fd, function(err) {
511
+ return fs$close.call(fs3, fd, function(err) {
512
512
  if (!err) {
513
513
  resetQueue();
514
514
  }
@@ -520,48 +520,48 @@ var require_graceful_fs = __commonJS({
520
520
  value: fs$close
521
521
  });
522
522
  return close;
523
- }(fs2.close);
524
- fs2.closeSync = function(fs$closeSync) {
523
+ }(fs3.close);
524
+ fs3.closeSync = function(fs$closeSync) {
525
525
  function closeSync(fd) {
526
- fs$closeSync.apply(fs2, arguments);
526
+ fs$closeSync.apply(fs3, arguments);
527
527
  resetQueue();
528
528
  }
529
529
  Object.defineProperty(closeSync, previousSymbol, {
530
530
  value: fs$closeSync
531
531
  });
532
532
  return closeSync;
533
- }(fs2.closeSync);
533
+ }(fs3.closeSync);
534
534
  if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
535
535
  process.on("exit", function() {
536
- debug2(fs2[gracefulQueue]);
537
- __require("assert").equal(fs2[gracefulQueue].length, 0);
536
+ debug2(fs3[gracefulQueue]);
537
+ __require("assert").equal(fs3[gracefulQueue].length, 0);
538
538
  });
539
539
  }
540
540
  }
541
541
  var queue;
542
542
  if (!global[gracefulQueue]) {
543
- publishQueue(global, fs2[gracefulQueue]);
544
- }
545
- module.exports = patch(clone(fs2));
546
- if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs2.__patched) {
547
- module.exports = patch(fs2);
548
- fs2.__patched = true;
549
- }
550
- function patch(fs3) {
551
- polyfills(fs3);
552
- fs3.gracefulify = patch;
553
- fs3.createReadStream = createReadStream;
554
- fs3.createWriteStream = createWriteStream;
555
- var fs$readFile = fs3.readFile;
556
- fs3.readFile = readFile;
557
- function readFile(path5, options, cb) {
543
+ publishQueue(global, fs3[gracefulQueue]);
544
+ }
545
+ module.exports = patch(clone(fs3));
546
+ if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs3.__patched) {
547
+ module.exports = patch(fs3);
548
+ fs3.__patched = true;
549
+ }
550
+ function patch(fs4) {
551
+ polyfills(fs4);
552
+ fs4.gracefulify = patch;
553
+ fs4.createReadStream = createReadStream;
554
+ fs4.createWriteStream = createWriteStream;
555
+ var fs$readFile = fs4.readFile;
556
+ fs4.readFile = readFile;
557
+ function readFile(path6, options, cb) {
558
558
  if (typeof options === "function")
559
559
  cb = options, options = null;
560
- return go$readFile(path5, options, cb);
561
- function go$readFile(path6, options2, cb2, startTime) {
562
- return fs$readFile(path6, options2, function(err) {
560
+ return go$readFile(path6, options, cb);
561
+ function go$readFile(path7, options2, cb2, startTime) {
562
+ return fs$readFile(path7, options2, function(err) {
563
563
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
564
- enqueue([go$readFile, [path6, options2, cb2], err, startTime || Date.now(), Date.now()]);
564
+ enqueue([go$readFile, [path7, options2, cb2], err, startTime || Date.now(), Date.now()]);
565
565
  else {
566
566
  if (typeof cb2 === "function")
567
567
  cb2.apply(this, arguments);
@@ -569,16 +569,16 @@ var require_graceful_fs = __commonJS({
569
569
  });
570
570
  }
571
571
  }
572
- var fs$writeFile = fs3.writeFile;
573
- fs3.writeFile = writeFile;
574
- function writeFile(path5, data, options, cb) {
572
+ var fs$writeFile = fs4.writeFile;
573
+ fs4.writeFile = writeFile;
574
+ function writeFile(path6, data, options, cb) {
575
575
  if (typeof options === "function")
576
576
  cb = options, options = null;
577
- return go$writeFile(path5, data, options, cb);
578
- function go$writeFile(path6, data2, options2, cb2, startTime) {
579
- return fs$writeFile(path6, data2, options2, function(err) {
577
+ return go$writeFile(path6, data, options, cb);
578
+ function go$writeFile(path7, data2, options2, cb2, startTime) {
579
+ return fs$writeFile(path7, data2, options2, function(err) {
580
580
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
581
- enqueue([go$writeFile, [path6, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
581
+ enqueue([go$writeFile, [path7, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
582
582
  else {
583
583
  if (typeof cb2 === "function")
584
584
  cb2.apply(this, arguments);
@@ -586,17 +586,17 @@ var require_graceful_fs = __commonJS({
586
586
  });
587
587
  }
588
588
  }
589
- var fs$appendFile = fs3.appendFile;
589
+ var fs$appendFile = fs4.appendFile;
590
590
  if (fs$appendFile)
591
- fs3.appendFile = appendFile;
592
- function appendFile(path5, data, options, cb) {
591
+ fs4.appendFile = appendFile;
592
+ function appendFile(path6, data, options, cb) {
593
593
  if (typeof options === "function")
594
594
  cb = options, options = null;
595
- return go$appendFile(path5, data, options, cb);
596
- function go$appendFile(path6, data2, options2, cb2, startTime) {
597
- return fs$appendFile(path6, data2, options2, function(err) {
595
+ return go$appendFile(path6, data, options, cb);
596
+ function go$appendFile(path7, data2, options2, cb2, startTime) {
597
+ return fs$appendFile(path7, data2, options2, function(err) {
598
598
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
599
- enqueue([go$appendFile, [path6, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
599
+ enqueue([go$appendFile, [path7, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
600
600
  else {
601
601
  if (typeof cb2 === "function")
602
602
  cb2.apply(this, arguments);
@@ -604,9 +604,9 @@ var require_graceful_fs = __commonJS({
604
604
  });
605
605
  }
606
606
  }
607
- var fs$copyFile = fs3.copyFile;
607
+ var fs$copyFile = fs4.copyFile;
608
608
  if (fs$copyFile)
609
- fs3.copyFile = copyFile;
609
+ fs4.copyFile = copyFile;
610
610
  function copyFile(src, dest, flags, cb) {
611
611
  if (typeof flags === "function") {
612
612
  cb = flags;
@@ -624,34 +624,34 @@ var require_graceful_fs = __commonJS({
624
624
  });
625
625
  }
626
626
  }
627
- var fs$readdir = fs3.readdir;
628
- fs3.readdir = readdir;
627
+ var fs$readdir = fs4.readdir;
628
+ fs4.readdir = readdir;
629
629
  var noReaddirOptionVersions = /^v[0-5]\./;
630
- function readdir(path5, options, cb) {
630
+ function readdir(path6, options, cb) {
631
631
  if (typeof options === "function")
632
632
  cb = options, options = null;
633
- var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path6, options2, cb2, startTime) {
634
- return fs$readdir(path6, fs$readdirCallback(
635
- path6,
633
+ var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path7, options2, cb2, startTime) {
634
+ return fs$readdir(path7, fs$readdirCallback(
635
+ path7,
636
636
  options2,
637
637
  cb2,
638
638
  startTime
639
639
  ));
640
- } : function go$readdir2(path6, options2, cb2, startTime) {
641
- return fs$readdir(path6, options2, fs$readdirCallback(
642
- path6,
640
+ } : function go$readdir2(path7, options2, cb2, startTime) {
641
+ return fs$readdir(path7, options2, fs$readdirCallback(
642
+ path7,
643
643
  options2,
644
644
  cb2,
645
645
  startTime
646
646
  ));
647
647
  };
648
- return go$readdir(path5, options, cb);
649
- function fs$readdirCallback(path6, options2, cb2, startTime) {
648
+ return go$readdir(path6, options, cb);
649
+ function fs$readdirCallback(path7, options2, cb2, startTime) {
650
650
  return function(err, files) {
651
651
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
652
652
  enqueue([
653
653
  go$readdir,
654
- [path6, options2, cb2],
654
+ [path7, options2, cb2],
655
655
  err,
656
656
  startTime || Date.now(),
657
657
  Date.now()
@@ -666,21 +666,21 @@ var require_graceful_fs = __commonJS({
666
666
  }
667
667
  }
668
668
  if (process.version.substr(0, 4) === "v0.8") {
669
- var legStreams = legacy(fs3);
669
+ var legStreams = legacy(fs4);
670
670
  ReadStream = legStreams.ReadStream;
671
671
  WriteStream = legStreams.WriteStream;
672
672
  }
673
- var fs$ReadStream = fs3.ReadStream;
673
+ var fs$ReadStream = fs4.ReadStream;
674
674
  if (fs$ReadStream) {
675
675
  ReadStream.prototype = Object.create(fs$ReadStream.prototype);
676
676
  ReadStream.prototype.open = ReadStream$open;
677
677
  }
678
- var fs$WriteStream = fs3.WriteStream;
678
+ var fs$WriteStream = fs4.WriteStream;
679
679
  if (fs$WriteStream) {
680
680
  WriteStream.prototype = Object.create(fs$WriteStream.prototype);
681
681
  WriteStream.prototype.open = WriteStream$open;
682
682
  }
683
- Object.defineProperty(fs3, "ReadStream", {
683
+ Object.defineProperty(fs4, "ReadStream", {
684
684
  get: function() {
685
685
  return ReadStream;
686
686
  },
@@ -690,7 +690,7 @@ var require_graceful_fs = __commonJS({
690
690
  enumerable: true,
691
691
  configurable: true
692
692
  });
693
- Object.defineProperty(fs3, "WriteStream", {
693
+ Object.defineProperty(fs4, "WriteStream", {
694
694
  get: function() {
695
695
  return WriteStream;
696
696
  },
@@ -701,7 +701,7 @@ var require_graceful_fs = __commonJS({
701
701
  configurable: true
702
702
  });
703
703
  var FileReadStream = ReadStream;
704
- Object.defineProperty(fs3, "FileReadStream", {
704
+ Object.defineProperty(fs4, "FileReadStream", {
705
705
  get: function() {
706
706
  return FileReadStream;
707
707
  },
@@ -712,7 +712,7 @@ var require_graceful_fs = __commonJS({
712
712
  configurable: true
713
713
  });
714
714
  var FileWriteStream = WriteStream;
715
- Object.defineProperty(fs3, "FileWriteStream", {
715
+ Object.defineProperty(fs4, "FileWriteStream", {
716
716
  get: function() {
717
717
  return FileWriteStream;
718
718
  },
@@ -722,7 +722,7 @@ var require_graceful_fs = __commonJS({
722
722
  enumerable: true,
723
723
  configurable: true
724
724
  });
725
- function ReadStream(path5, options) {
725
+ function ReadStream(path6, options) {
726
726
  if (this instanceof ReadStream)
727
727
  return fs$ReadStream.apply(this, arguments), this;
728
728
  else
@@ -742,7 +742,7 @@ var require_graceful_fs = __commonJS({
742
742
  }
743
743
  });
744
744
  }
745
- function WriteStream(path5, options) {
745
+ function WriteStream(path6, options) {
746
746
  if (this instanceof WriteStream)
747
747
  return fs$WriteStream.apply(this, arguments), this;
748
748
  else
@@ -760,22 +760,22 @@ var require_graceful_fs = __commonJS({
760
760
  }
761
761
  });
762
762
  }
763
- function createReadStream(path5, options) {
764
- return new fs3.ReadStream(path5, options);
763
+ function createReadStream(path6, options) {
764
+ return new fs4.ReadStream(path6, options);
765
765
  }
766
- function createWriteStream(path5, options) {
767
- return new fs3.WriteStream(path5, options);
766
+ function createWriteStream(path6, options) {
767
+ return new fs4.WriteStream(path6, options);
768
768
  }
769
- var fs$open = fs3.open;
770
- fs3.open = open;
771
- function open(path5, flags, mode, cb) {
769
+ var fs$open = fs4.open;
770
+ fs4.open = open;
771
+ function open(path6, flags, mode, cb) {
772
772
  if (typeof mode === "function")
773
773
  cb = mode, mode = null;
774
- return go$open(path5, flags, mode, cb);
775
- function go$open(path6, flags2, mode2, cb2, startTime) {
776
- return fs$open(path6, flags2, mode2, function(err, fd) {
774
+ return go$open(path6, flags, mode, cb);
775
+ function go$open(path7, flags2, mode2, cb2, startTime) {
776
+ return fs$open(path7, flags2, mode2, function(err, fd) {
777
777
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
778
- enqueue([go$open, [path6, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
778
+ enqueue([go$open, [path7, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
779
779
  else {
780
780
  if (typeof cb2 === "function")
781
781
  cb2.apply(this, arguments);
@@ -783,20 +783,20 @@ var require_graceful_fs = __commonJS({
783
783
  });
784
784
  }
785
785
  }
786
- return fs3;
786
+ return fs4;
787
787
  }
788
788
  function enqueue(elem) {
789
789
  debug2("ENQUEUE", elem[0].name, elem[1]);
790
- fs2[gracefulQueue].push(elem);
790
+ fs3[gracefulQueue].push(elem);
791
791
  retry();
792
792
  }
793
793
  var retryTimer;
794
794
  function resetQueue() {
795
795
  var now = Date.now();
796
- for (var i = 0; i < fs2[gracefulQueue].length; ++i) {
797
- if (fs2[gracefulQueue][i].length > 2) {
798
- fs2[gracefulQueue][i][3] = now;
799
- fs2[gracefulQueue][i][4] = now;
796
+ for (var i = 0; i < fs3[gracefulQueue].length; ++i) {
797
+ if (fs3[gracefulQueue][i].length > 2) {
798
+ fs3[gracefulQueue][i][3] = now;
799
+ fs3[gracefulQueue][i][4] = now;
800
800
  }
801
801
  }
802
802
  retry();
@@ -804,9 +804,9 @@ var require_graceful_fs = __commonJS({
804
804
  function retry() {
805
805
  clearTimeout(retryTimer);
806
806
  retryTimer = void 0;
807
- if (fs2[gracefulQueue].length === 0)
807
+ if (fs3[gracefulQueue].length === 0)
808
808
  return;
809
- var elem = fs2[gracefulQueue].shift();
809
+ var elem = fs3[gracefulQueue].shift();
810
810
  var fn = elem[0];
811
811
  var args = elem[1];
812
812
  var err = elem[2];
@@ -828,7 +828,7 @@ var require_graceful_fs = __commonJS({
828
828
  debug2("RETRY", fn.name, args);
829
829
  fn.apply(null, args.concat([startTime]));
830
830
  } else {
831
- fs2[gracefulQueue].push(elem);
831
+ fs3[gracefulQueue].push(elem);
832
832
  }
833
833
  }
834
834
  if (retryTimer === void 0) {
@@ -843,7 +843,7 @@ var require_fs = __commonJS({
843
843
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/fs/index.js"(exports) {
844
844
  "use strict";
845
845
  var u = require_universalify().fromCallback;
846
- var fs2 = require_graceful_fs();
846
+ var fs3 = require_graceful_fs();
847
847
  var api = [
848
848
  "access",
849
849
  "appendFile",
@@ -884,26 +884,26 @@ var require_fs = __commonJS({
884
884
  "utimes",
885
885
  "writeFile"
886
886
  ].filter((key) => {
887
- return typeof fs2[key] === "function";
887
+ return typeof fs3[key] === "function";
888
888
  });
889
- Object.assign(exports, fs2);
889
+ Object.assign(exports, fs3);
890
890
  api.forEach((method3) => {
891
- exports[method3] = u(fs2[method3]);
891
+ exports[method3] = u(fs3[method3]);
892
892
  });
893
893
  exports.exists = function(filename, callback) {
894
894
  if (typeof callback === "function") {
895
- return fs2.exists(filename, callback);
895
+ return fs3.exists(filename, callback);
896
896
  }
897
897
  return new Promise((resolve) => {
898
- return fs2.exists(filename, resolve);
898
+ return fs3.exists(filename, resolve);
899
899
  });
900
900
  };
901
901
  exports.read = function(fd, buffer, offset, length, position, callback) {
902
902
  if (typeof callback === "function") {
903
- return fs2.read(fd, buffer, offset, length, position, callback);
903
+ return fs3.read(fd, buffer, offset, length, position, callback);
904
904
  }
905
905
  return new Promise((resolve, reject) => {
906
- fs2.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
906
+ fs3.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
907
907
  if (err) return reject(err);
908
908
  resolve({ bytesRead, buffer: buffer2 });
909
909
  });
@@ -911,10 +911,10 @@ var require_fs = __commonJS({
911
911
  };
912
912
  exports.write = function(fd, buffer, ...args) {
913
913
  if (typeof args[args.length - 1] === "function") {
914
- return fs2.write(fd, buffer, ...args);
914
+ return fs3.write(fd, buffer, ...args);
915
915
  }
916
916
  return new Promise((resolve, reject) => {
917
- fs2.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
917
+ fs3.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
918
918
  if (err) return reject(err);
919
919
  resolve({ bytesWritten, buffer: buffer2 });
920
920
  });
@@ -922,10 +922,10 @@ var require_fs = __commonJS({
922
922
  };
923
923
  exports.readv = function(fd, buffers, ...args) {
924
924
  if (typeof args[args.length - 1] === "function") {
925
- return fs2.readv(fd, buffers, ...args);
925
+ return fs3.readv(fd, buffers, ...args);
926
926
  }
927
927
  return new Promise((resolve, reject) => {
928
- fs2.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
928
+ fs3.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
929
929
  if (err) return reject(err);
930
930
  resolve({ bytesRead, buffers: buffers2 });
931
931
  });
@@ -933,17 +933,17 @@ var require_fs = __commonJS({
933
933
  };
934
934
  exports.writev = function(fd, buffers, ...args) {
935
935
  if (typeof args[args.length - 1] === "function") {
936
- return fs2.writev(fd, buffers, ...args);
936
+ return fs3.writev(fd, buffers, ...args);
937
937
  }
938
938
  return new Promise((resolve, reject) => {
939
- fs2.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
939
+ fs3.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
940
940
  if (err) return reject(err);
941
941
  resolve({ bytesWritten, buffers: buffers2 });
942
942
  });
943
943
  });
944
944
  };
945
- if (typeof fs2.realpath.native === "function") {
946
- exports.realpath.native = u(fs2.realpath.native);
945
+ if (typeof fs3.realpath.native === "function") {
946
+ exports.realpath.native = u(fs3.realpath.native);
947
947
  } else {
948
948
  process.emitWarning(
949
949
  "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -958,10 +958,10 @@ var require_fs = __commonJS({
958
958
  var require_utils = __commonJS({
959
959
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/mkdirs/utils.js"(exports, module) {
960
960
  "use strict";
961
- var path5 = __require("path");
961
+ var path6 = __require("path");
962
962
  module.exports.checkPath = function checkPath(pth) {
963
963
  if (process.platform === "win32") {
964
- const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path5.parse(pth).root, ""));
964
+ const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path6.parse(pth).root, ""));
965
965
  if (pathHasInvalidWinCharacters) {
966
966
  const error = new Error(`Path contains invalid characters: ${pth}`);
967
967
  error.code = "EINVAL";
@@ -976,7 +976,7 @@ var require_utils = __commonJS({
976
976
  var require_make_dir = __commonJS({
977
977
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module) {
978
978
  "use strict";
979
- var fs2 = require_fs();
979
+ var fs3 = require_fs();
980
980
  var { checkPath } = require_utils();
981
981
  var getMode = (options) => {
982
982
  const defaults = { mode: 511 };
@@ -985,14 +985,14 @@ var require_make_dir = __commonJS({
985
985
  };
986
986
  module.exports.makeDir = async (dir, options) => {
987
987
  checkPath(dir);
988
- return fs2.mkdir(dir, {
988
+ return fs3.mkdir(dir, {
989
989
  mode: getMode(options),
990
990
  recursive: true
991
991
  });
992
992
  };
993
993
  module.exports.makeDirSync = (dir, options) => {
994
994
  checkPath(dir);
995
- return fs2.mkdirSync(dir, {
995
+ return fs3.mkdirSync(dir, {
996
996
  mode: getMode(options),
997
997
  recursive: true
998
998
  });
@@ -1024,13 +1024,13 @@ var require_path_exists = __commonJS({
1024
1024
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/path-exists/index.js"(exports, module) {
1025
1025
  "use strict";
1026
1026
  var u = require_universalify().fromPromise;
1027
- var fs2 = require_fs();
1028
- function pathExists(path5) {
1029
- return fs2.access(path5).then(() => true).catch(() => false);
1027
+ var fs3 = require_fs();
1028
+ function pathExists(path6) {
1029
+ return fs3.access(path6).then(() => true).catch(() => false);
1030
1030
  }
1031
1031
  module.exports = {
1032
1032
  pathExists: u(pathExists),
1033
- pathExistsSync: fs2.existsSync
1033
+ pathExistsSync: fs3.existsSync
1034
1034
  };
1035
1035
  }
1036
1036
  });
@@ -1039,16 +1039,16 @@ var require_path_exists = __commonJS({
1039
1039
  var require_utimes = __commonJS({
1040
1040
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/util/utimes.js"(exports, module) {
1041
1041
  "use strict";
1042
- var fs2 = require_fs();
1042
+ var fs3 = require_fs();
1043
1043
  var u = require_universalify().fromPromise;
1044
- async function utimesMillis(path5, atime, mtime) {
1045
- const fd = await fs2.open(path5, "r+");
1044
+ async function utimesMillis(path6, atime, mtime) {
1045
+ const fd = await fs3.open(path6, "r+");
1046
1046
  let closeErr = null;
1047
1047
  try {
1048
- await fs2.futimes(fd, atime, mtime);
1048
+ await fs3.futimes(fd, atime, mtime);
1049
1049
  } finally {
1050
1050
  try {
1051
- await fs2.close(fd);
1051
+ await fs3.close(fd);
1052
1052
  } catch (e) {
1053
1053
  closeErr = e;
1054
1054
  }
@@ -1057,10 +1057,10 @@ var require_utimes = __commonJS({
1057
1057
  throw closeErr;
1058
1058
  }
1059
1059
  }
1060
- function utimesMillisSync(path5, atime, mtime) {
1061
- const fd = fs2.openSync(path5, "r+");
1062
- fs2.futimesSync(fd, atime, mtime);
1063
- return fs2.closeSync(fd);
1060
+ function utimesMillisSync(path6, atime, mtime) {
1061
+ const fd = fs3.openSync(path6, "r+");
1062
+ fs3.futimesSync(fd, atime, mtime);
1063
+ return fs3.closeSync(fd);
1064
1064
  }
1065
1065
  module.exports = {
1066
1066
  utimesMillis: u(utimesMillis),
@@ -1073,11 +1073,11 @@ var require_utimes = __commonJS({
1073
1073
  var require_stat = __commonJS({
1074
1074
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/util/stat.js"(exports, module) {
1075
1075
  "use strict";
1076
- var fs2 = require_fs();
1077
- var path5 = __require("path");
1076
+ var fs3 = require_fs();
1077
+ var path6 = __require("path");
1078
1078
  var u = require_universalify().fromPromise;
1079
1079
  function getStats(src, dest, opts) {
1080
- const statFunc = opts.dereference ? (file4) => fs2.stat(file4, { bigint: true }) : (file4) => fs2.lstat(file4, { bigint: true });
1080
+ const statFunc = opts.dereference ? (file4) => fs3.stat(file4, { bigint: true }) : (file4) => fs3.lstat(file4, { bigint: true });
1081
1081
  return Promise.all([
1082
1082
  statFunc(src),
1083
1083
  statFunc(dest).catch((err) => {
@@ -1088,7 +1088,7 @@ var require_stat = __commonJS({
1088
1088
  }
1089
1089
  function getStatsSync(src, dest, opts) {
1090
1090
  let destStat;
1091
- const statFunc = opts.dereference ? (file4) => fs2.statSync(file4, { bigint: true }) : (file4) => fs2.lstatSync(file4, { bigint: true });
1091
+ const statFunc = opts.dereference ? (file4) => fs3.statSync(file4, { bigint: true }) : (file4) => fs3.lstatSync(file4, { bigint: true });
1092
1092
  const srcStat = statFunc(src);
1093
1093
  try {
1094
1094
  destStat = statFunc(dest);
@@ -1102,8 +1102,8 @@ var require_stat = __commonJS({
1102
1102
  const { srcStat, destStat } = await getStats(src, dest, opts);
1103
1103
  if (destStat) {
1104
1104
  if (areIdentical(srcStat, destStat)) {
1105
- const srcBaseName = path5.basename(src);
1106
- const destBaseName = path5.basename(dest);
1105
+ const srcBaseName = path6.basename(src);
1106
+ const destBaseName = path6.basename(dest);
1107
1107
  if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
1108
1108
  return { srcStat, destStat, isChangingCase: true };
1109
1109
  }
@@ -1125,8 +1125,8 @@ var require_stat = __commonJS({
1125
1125
  const { srcStat, destStat } = getStatsSync(src, dest, opts);
1126
1126
  if (destStat) {
1127
1127
  if (areIdentical(srcStat, destStat)) {
1128
- const srcBaseName = path5.basename(src);
1129
- const destBaseName = path5.basename(dest);
1128
+ const srcBaseName = path6.basename(src);
1129
+ const destBaseName = path6.basename(dest);
1130
1130
  if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
1131
1131
  return { srcStat, destStat, isChangingCase: true };
1132
1132
  }
@@ -1145,12 +1145,12 @@ var require_stat = __commonJS({
1145
1145
  return { srcStat, destStat };
1146
1146
  }
1147
1147
  async function checkParentPaths(src, srcStat, dest, funcName) {
1148
- const srcParent = path5.resolve(path5.dirname(src));
1149
- const destParent = path5.resolve(path5.dirname(dest));
1150
- if (destParent === srcParent || destParent === path5.parse(destParent).root) return;
1148
+ const srcParent = path6.resolve(path6.dirname(src));
1149
+ const destParent = path6.resolve(path6.dirname(dest));
1150
+ if (destParent === srcParent || destParent === path6.parse(destParent).root) return;
1151
1151
  let destStat;
1152
1152
  try {
1153
- destStat = await fs2.stat(destParent, { bigint: true });
1153
+ destStat = await fs3.stat(destParent, { bigint: true });
1154
1154
  } catch (err) {
1155
1155
  if (err.code === "ENOENT") return;
1156
1156
  throw err;
@@ -1161,12 +1161,12 @@ var require_stat = __commonJS({
1161
1161
  return checkParentPaths(src, srcStat, destParent, funcName);
1162
1162
  }
1163
1163
  function checkParentPathsSync(src, srcStat, dest, funcName) {
1164
- const srcParent = path5.resolve(path5.dirname(src));
1165
- const destParent = path5.resolve(path5.dirname(dest));
1166
- if (destParent === srcParent || destParent === path5.parse(destParent).root) return;
1164
+ const srcParent = path6.resolve(path6.dirname(src));
1165
+ const destParent = path6.resolve(path6.dirname(dest));
1166
+ if (destParent === srcParent || destParent === path6.parse(destParent).root) return;
1167
1167
  let destStat;
1168
1168
  try {
1169
- destStat = fs2.statSync(destParent, { bigint: true });
1169
+ destStat = fs3.statSync(destParent, { bigint: true });
1170
1170
  } catch (err) {
1171
1171
  if (err.code === "ENOENT") return;
1172
1172
  throw err;
@@ -1180,8 +1180,8 @@ var require_stat = __commonJS({
1180
1180
  return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
1181
1181
  }
1182
1182
  function isSrcSubdir(src, dest) {
1183
- const srcArr = path5.resolve(src).split(path5.sep).filter((i) => i);
1184
- const destArr = path5.resolve(dest).split(path5.sep).filter((i) => i);
1183
+ const srcArr = path6.resolve(src).split(path6.sep).filter((i) => i);
1184
+ const destArr = path6.resolve(dest).split(path6.sep).filter((i) => i);
1185
1185
  return srcArr.every((cur, i) => destArr[i] === cur);
1186
1186
  }
1187
1187
  function errMsg(src, dest, funcName) {
@@ -1205,8 +1205,8 @@ var require_stat = __commonJS({
1205
1205
  var require_copy = __commonJS({
1206
1206
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/copy/copy.js"(exports, module) {
1207
1207
  "use strict";
1208
- var fs2 = require_fs();
1209
- var path5 = __require("path");
1208
+ var fs3 = require_fs();
1209
+ var path6 = __require("path");
1210
1210
  var { mkdirs } = require_mkdirs();
1211
1211
  var { pathExists } = require_path_exists();
1212
1212
  var { utimesMillis } = require_utimes();
@@ -1228,7 +1228,7 @@ var require_copy = __commonJS({
1228
1228
  await stat.checkParentPaths(src, srcStat, dest, "copy");
1229
1229
  const include = await runFilter(src, dest, opts);
1230
1230
  if (!include) return;
1231
- const destParent = path5.dirname(dest);
1231
+ const destParent = path6.dirname(dest);
1232
1232
  const dirExists = await pathExists(destParent);
1233
1233
  if (!dirExists) {
1234
1234
  await mkdirs(destParent);
@@ -1240,7 +1240,7 @@ var require_copy = __commonJS({
1240
1240
  return opts.filter(src, dest);
1241
1241
  }
1242
1242
  async function getStatsAndPerformCopy(destStat, src, dest, opts) {
1243
- const statFn = opts.dereference ? fs2.stat : fs2.lstat;
1243
+ const statFn = opts.dereference ? fs3.stat : fs3.lstat;
1244
1244
  const srcStat = await statFn(src);
1245
1245
  if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
1246
1246
  if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -1252,7 +1252,7 @@ var require_copy = __commonJS({
1252
1252
  async function onFile(srcStat, destStat, src, dest, opts) {
1253
1253
  if (!destStat) return copyFile(srcStat, src, dest, opts);
1254
1254
  if (opts.overwrite) {
1255
- await fs2.unlink(dest);
1255
+ await fs3.unlink(dest);
1256
1256
  return copyFile(srcStat, src, dest, opts);
1257
1257
  }
1258
1258
  if (opts.errorOnExist) {
@@ -1260,30 +1260,30 @@ var require_copy = __commonJS({
1260
1260
  }
1261
1261
  }
1262
1262
  async function copyFile(srcStat, src, dest, opts) {
1263
- await fs2.copyFile(src, dest);
1263
+ await fs3.copyFile(src, dest);
1264
1264
  if (opts.preserveTimestamps) {
1265
1265
  if (fileIsNotWritable(srcStat.mode)) {
1266
1266
  await makeFileWritable(dest, srcStat.mode);
1267
1267
  }
1268
- const updatedSrcStat = await fs2.stat(src);
1268
+ const updatedSrcStat = await fs3.stat(src);
1269
1269
  await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
1270
1270
  }
1271
- return fs2.chmod(dest, srcStat.mode);
1271
+ return fs3.chmod(dest, srcStat.mode);
1272
1272
  }
1273
1273
  function fileIsNotWritable(srcMode) {
1274
1274
  return (srcMode & 128) === 0;
1275
1275
  }
1276
1276
  function makeFileWritable(dest, srcMode) {
1277
- return fs2.chmod(dest, srcMode | 128);
1277
+ return fs3.chmod(dest, srcMode | 128);
1278
1278
  }
1279
1279
  async function onDir(srcStat, destStat, src, dest, opts) {
1280
1280
  if (!destStat) {
1281
- await fs2.mkdir(dest);
1281
+ await fs3.mkdir(dest);
1282
1282
  }
1283
1283
  const promises = [];
1284
- for await (const item of await fs2.opendir(src)) {
1285
- const srcItem = path5.join(src, item.name);
1286
- const destItem = path5.join(dest, item.name);
1284
+ for await (const item of await fs3.opendir(src)) {
1285
+ const srcItem = path6.join(src, item.name);
1286
+ const destItem = path6.join(dest, item.name);
1287
1287
  promises.push(
1288
1288
  runFilter(srcItem, destItem, opts).then((include) => {
1289
1289
  if (include) {
@@ -1296,26 +1296,26 @@ var require_copy = __commonJS({
1296
1296
  }
1297
1297
  await Promise.all(promises);
1298
1298
  if (!destStat) {
1299
- await fs2.chmod(dest, srcStat.mode);
1299
+ await fs3.chmod(dest, srcStat.mode);
1300
1300
  }
1301
1301
  }
1302
1302
  async function onLink(destStat, src, dest, opts) {
1303
- let resolvedSrc = await fs2.readlink(src);
1303
+ let resolvedSrc = await fs3.readlink(src);
1304
1304
  if (opts.dereference) {
1305
- resolvedSrc = path5.resolve(process.cwd(), resolvedSrc);
1305
+ resolvedSrc = path6.resolve(process.cwd(), resolvedSrc);
1306
1306
  }
1307
1307
  if (!destStat) {
1308
- return fs2.symlink(resolvedSrc, dest);
1308
+ return fs3.symlink(resolvedSrc, dest);
1309
1309
  }
1310
1310
  let resolvedDest = null;
1311
1311
  try {
1312
- resolvedDest = await fs2.readlink(dest);
1312
+ resolvedDest = await fs3.readlink(dest);
1313
1313
  } catch (e) {
1314
- if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs2.symlink(resolvedSrc, dest);
1314
+ if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs3.symlink(resolvedSrc, dest);
1315
1315
  throw e;
1316
1316
  }
1317
1317
  if (opts.dereference) {
1318
- resolvedDest = path5.resolve(process.cwd(), resolvedDest);
1318
+ resolvedDest = path6.resolve(process.cwd(), resolvedDest);
1319
1319
  }
1320
1320
  if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
1321
1321
  throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
@@ -1323,8 +1323,8 @@ var require_copy = __commonJS({
1323
1323
  if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
1324
1324
  throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
1325
1325
  }
1326
- await fs2.unlink(dest);
1327
- return fs2.symlink(resolvedSrc, dest);
1326
+ await fs3.unlink(dest);
1327
+ return fs3.symlink(resolvedSrc, dest);
1328
1328
  }
1329
1329
  module.exports = copy;
1330
1330
  }
@@ -1334,8 +1334,8 @@ var require_copy = __commonJS({
1334
1334
  var require_copy_sync = __commonJS({
1335
1335
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module) {
1336
1336
  "use strict";
1337
- var fs2 = require_graceful_fs();
1338
- var path5 = __require("path");
1337
+ var fs3 = require_graceful_fs();
1338
+ var path6 = __require("path");
1339
1339
  var mkdirsSync = require_mkdirs().mkdirsSync;
1340
1340
  var utimesMillisSync = require_utimes().utimesMillisSync;
1341
1341
  var stat = require_stat();
@@ -1356,12 +1356,12 @@ var require_copy_sync = __commonJS({
1356
1356
  const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy", opts);
1357
1357
  stat.checkParentPathsSync(src, srcStat, dest, "copy");
1358
1358
  if (opts.filter && !opts.filter(src, dest)) return;
1359
- const destParent = path5.dirname(dest);
1360
- if (!fs2.existsSync(destParent)) mkdirsSync(destParent);
1359
+ const destParent = path6.dirname(dest);
1360
+ if (!fs3.existsSync(destParent)) mkdirsSync(destParent);
1361
1361
  return getStats(destStat, src, dest, opts);
1362
1362
  }
1363
1363
  function getStats(destStat, src, dest, opts) {
1364
- const statSync = opts.dereference ? fs2.statSync : fs2.lstatSync;
1364
+ const statSync = opts.dereference ? fs3.statSync : fs3.lstatSync;
1365
1365
  const srcStat = statSync(src);
1366
1366
  if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
1367
1367
  else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -1376,14 +1376,14 @@ var require_copy_sync = __commonJS({
1376
1376
  }
1377
1377
  function mayCopyFile(srcStat, src, dest, opts) {
1378
1378
  if (opts.overwrite) {
1379
- fs2.unlinkSync(dest);
1379
+ fs3.unlinkSync(dest);
1380
1380
  return copyFile(srcStat, src, dest, opts);
1381
1381
  } else if (opts.errorOnExist) {
1382
1382
  throw new Error(`'${dest}' already exists`);
1383
1383
  }
1384
1384
  }
1385
1385
  function copyFile(srcStat, src, dest, opts) {
1386
- fs2.copyFileSync(src, dest);
1386
+ fs3.copyFileSync(src, dest);
1387
1387
  if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
1388
1388
  return setDestMode(dest, srcStat.mode);
1389
1389
  }
@@ -1398,10 +1398,10 @@ var require_copy_sync = __commonJS({
1398
1398
  return setDestMode(dest, srcMode | 128);
1399
1399
  }
1400
1400
  function setDestMode(dest, srcMode) {
1401
- return fs2.chmodSync(dest, srcMode);
1401
+ return fs3.chmodSync(dest, srcMode);
1402
1402
  }
1403
1403
  function setDestTimestamps(src, dest) {
1404
- const updatedSrcStat = fs2.statSync(src);
1404
+ const updatedSrcStat = fs3.statSync(src);
1405
1405
  return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
1406
1406
  }
1407
1407
  function onDir(srcStat, destStat, src, dest, opts) {
@@ -1409,12 +1409,12 @@ var require_copy_sync = __commonJS({
1409
1409
  return copyDir(src, dest, opts);
1410
1410
  }
1411
1411
  function mkDirAndCopy(srcMode, src, dest, opts) {
1412
- fs2.mkdirSync(dest);
1412
+ fs3.mkdirSync(dest);
1413
1413
  copyDir(src, dest, opts);
1414
1414
  return setDestMode(dest, srcMode);
1415
1415
  }
1416
1416
  function copyDir(src, dest, opts) {
1417
- const dir = fs2.opendirSync(src);
1417
+ const dir = fs3.opendirSync(src);
1418
1418
  try {
1419
1419
  let dirent;
1420
1420
  while ((dirent = dir.readSync()) !== null) {
@@ -1425,29 +1425,29 @@ var require_copy_sync = __commonJS({
1425
1425
  }
1426
1426
  }
1427
1427
  function copyDirItem(item, src, dest, opts) {
1428
- const srcItem = path5.join(src, item);
1429
- const destItem = path5.join(dest, item);
1428
+ const srcItem = path6.join(src, item);
1429
+ const destItem = path6.join(dest, item);
1430
1430
  if (opts.filter && !opts.filter(srcItem, destItem)) return;
1431
1431
  const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
1432
1432
  return getStats(destStat, srcItem, destItem, opts);
1433
1433
  }
1434
1434
  function onLink(destStat, src, dest, opts) {
1435
- let resolvedSrc = fs2.readlinkSync(src);
1435
+ let resolvedSrc = fs3.readlinkSync(src);
1436
1436
  if (opts.dereference) {
1437
- resolvedSrc = path5.resolve(process.cwd(), resolvedSrc);
1437
+ resolvedSrc = path6.resolve(process.cwd(), resolvedSrc);
1438
1438
  }
1439
1439
  if (!destStat) {
1440
- return fs2.symlinkSync(resolvedSrc, dest);
1440
+ return fs3.symlinkSync(resolvedSrc, dest);
1441
1441
  } else {
1442
1442
  let resolvedDest;
1443
1443
  try {
1444
- resolvedDest = fs2.readlinkSync(dest);
1444
+ resolvedDest = fs3.readlinkSync(dest);
1445
1445
  } catch (err) {
1446
- if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs2.symlinkSync(resolvedSrc, dest);
1446
+ if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs3.symlinkSync(resolvedSrc, dest);
1447
1447
  throw err;
1448
1448
  }
1449
1449
  if (opts.dereference) {
1450
- resolvedDest = path5.resolve(process.cwd(), resolvedDest);
1450
+ resolvedDest = path6.resolve(process.cwd(), resolvedDest);
1451
1451
  }
1452
1452
  if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
1453
1453
  throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
@@ -1459,8 +1459,8 @@ var require_copy_sync = __commonJS({
1459
1459
  }
1460
1460
  }
1461
1461
  function copyLink(resolvedSrc, dest) {
1462
- fs2.unlinkSync(dest);
1463
- return fs2.symlinkSync(resolvedSrc, dest);
1462
+ fs3.unlinkSync(dest);
1463
+ return fs3.symlinkSync(resolvedSrc, dest);
1464
1464
  }
1465
1465
  module.exports = copySync;
1466
1466
  }
@@ -1482,13 +1482,13 @@ var require_copy2 = __commonJS({
1482
1482
  var require_remove = __commonJS({
1483
1483
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/remove/index.js"(exports, module) {
1484
1484
  "use strict";
1485
- var fs2 = require_graceful_fs();
1485
+ var fs3 = require_graceful_fs();
1486
1486
  var u = require_universalify().fromCallback;
1487
- function remove(path5, callback) {
1488
- fs2.rm(path5, { recursive: true, force: true }, callback);
1487
+ function remove(path6, callback) {
1488
+ fs3.rm(path6, { recursive: true, force: true }, callback);
1489
1489
  }
1490
- function removeSync(path5) {
1491
- fs2.rmSync(path5, { recursive: true, force: true });
1490
+ function removeSync(path6) {
1491
+ fs3.rmSync(path6, { recursive: true, force: true });
1492
1492
  }
1493
1493
  module.exports = {
1494
1494
  remove: u(remove),
@@ -1502,28 +1502,28 @@ var require_empty = __commonJS({
1502
1502
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/empty/index.js"(exports, module) {
1503
1503
  "use strict";
1504
1504
  var u = require_universalify().fromPromise;
1505
- var fs2 = require_fs();
1506
- var path5 = __require("path");
1505
+ var fs3 = require_fs();
1506
+ var path6 = __require("path");
1507
1507
  var mkdir = require_mkdirs();
1508
1508
  var remove = require_remove();
1509
1509
  var emptyDir = u(async function emptyDir2(dir) {
1510
1510
  let items;
1511
1511
  try {
1512
- items = await fs2.readdir(dir);
1512
+ items = await fs3.readdir(dir);
1513
1513
  } catch {
1514
1514
  return mkdir.mkdirs(dir);
1515
1515
  }
1516
- return Promise.all(items.map((item) => remove.remove(path5.join(dir, item))));
1516
+ return Promise.all(items.map((item) => remove.remove(path6.join(dir, item))));
1517
1517
  });
1518
1518
  function emptyDirSync(dir) {
1519
1519
  let items;
1520
1520
  try {
1521
- items = fs2.readdirSync(dir);
1521
+ items = fs3.readdirSync(dir);
1522
1522
  } catch {
1523
1523
  return mkdir.mkdirsSync(dir);
1524
1524
  }
1525
1525
  items.forEach((item) => {
1526
- item = path5.join(dir, item);
1526
+ item = path6.join(dir, item);
1527
1527
  remove.removeSync(item);
1528
1528
  });
1529
1529
  }
@@ -1541,52 +1541,52 @@ var require_file = __commonJS({
1541
1541
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/ensure/file.js"(exports, module) {
1542
1542
  "use strict";
1543
1543
  var u = require_universalify().fromPromise;
1544
- var path5 = __require("path");
1545
- var fs2 = require_fs();
1544
+ var path6 = __require("path");
1545
+ var fs3 = require_fs();
1546
1546
  var mkdir = require_mkdirs();
1547
1547
  async function createFile(file4) {
1548
1548
  let stats;
1549
1549
  try {
1550
- stats = await fs2.stat(file4);
1550
+ stats = await fs3.stat(file4);
1551
1551
  } catch {
1552
1552
  }
1553
1553
  if (stats && stats.isFile()) return;
1554
- const dir = path5.dirname(file4);
1554
+ const dir = path6.dirname(file4);
1555
1555
  let dirStats = null;
1556
1556
  try {
1557
- dirStats = await fs2.stat(dir);
1557
+ dirStats = await fs3.stat(dir);
1558
1558
  } catch (err) {
1559
1559
  if (err.code === "ENOENT") {
1560
1560
  await mkdir.mkdirs(dir);
1561
- await fs2.writeFile(file4, "");
1561
+ await fs3.writeFile(file4, "");
1562
1562
  return;
1563
1563
  } else {
1564
1564
  throw err;
1565
1565
  }
1566
1566
  }
1567
1567
  if (dirStats.isDirectory()) {
1568
- await fs2.writeFile(file4, "");
1568
+ await fs3.writeFile(file4, "");
1569
1569
  } else {
1570
- await fs2.readdir(dir);
1570
+ await fs3.readdir(dir);
1571
1571
  }
1572
1572
  }
1573
1573
  function createFileSync(file4) {
1574
1574
  let stats;
1575
1575
  try {
1576
- stats = fs2.statSync(file4);
1576
+ stats = fs3.statSync(file4);
1577
1577
  } catch {
1578
1578
  }
1579
1579
  if (stats && stats.isFile()) return;
1580
- const dir = path5.dirname(file4);
1580
+ const dir = path6.dirname(file4);
1581
1581
  try {
1582
- if (!fs2.statSync(dir).isDirectory()) {
1583
- fs2.readdirSync(dir);
1582
+ if (!fs3.statSync(dir).isDirectory()) {
1583
+ fs3.readdirSync(dir);
1584
1584
  }
1585
1585
  } catch (err) {
1586
1586
  if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
1587
1587
  else throw err;
1588
1588
  }
1589
- fs2.writeFileSync(file4, "");
1589
+ fs3.writeFileSync(file4, "");
1590
1590
  }
1591
1591
  module.exports = {
1592
1592
  createFile: u(createFile),
@@ -1600,50 +1600,50 @@ var require_link = __commonJS({
1600
1600
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/ensure/link.js"(exports, module) {
1601
1601
  "use strict";
1602
1602
  var u = require_universalify().fromPromise;
1603
- var path5 = __require("path");
1604
- var fs2 = require_fs();
1603
+ var path6 = __require("path");
1604
+ var fs3 = require_fs();
1605
1605
  var mkdir = require_mkdirs();
1606
1606
  var { pathExists } = require_path_exists();
1607
1607
  var { areIdentical } = require_stat();
1608
1608
  async function createLink(srcpath, dstpath) {
1609
1609
  let dstStat;
1610
1610
  try {
1611
- dstStat = await fs2.lstat(dstpath);
1611
+ dstStat = await fs3.lstat(dstpath);
1612
1612
  } catch {
1613
1613
  }
1614
1614
  let srcStat;
1615
1615
  try {
1616
- srcStat = await fs2.lstat(srcpath);
1616
+ srcStat = await fs3.lstat(srcpath);
1617
1617
  } catch (err) {
1618
1618
  err.message = err.message.replace("lstat", "ensureLink");
1619
1619
  throw err;
1620
1620
  }
1621
1621
  if (dstStat && areIdentical(srcStat, dstStat)) return;
1622
- const dir = path5.dirname(dstpath);
1622
+ const dir = path6.dirname(dstpath);
1623
1623
  const dirExists = await pathExists(dir);
1624
1624
  if (!dirExists) {
1625
1625
  await mkdir.mkdirs(dir);
1626
1626
  }
1627
- await fs2.link(srcpath, dstpath);
1627
+ await fs3.link(srcpath, dstpath);
1628
1628
  }
1629
1629
  function createLinkSync(srcpath, dstpath) {
1630
1630
  let dstStat;
1631
1631
  try {
1632
- dstStat = fs2.lstatSync(dstpath);
1632
+ dstStat = fs3.lstatSync(dstpath);
1633
1633
  } catch {
1634
1634
  }
1635
1635
  try {
1636
- const srcStat = fs2.lstatSync(srcpath);
1636
+ const srcStat = fs3.lstatSync(srcpath);
1637
1637
  if (dstStat && areIdentical(srcStat, dstStat)) return;
1638
1638
  } catch (err) {
1639
1639
  err.message = err.message.replace("lstat", "ensureLink");
1640
1640
  throw err;
1641
1641
  }
1642
- const dir = path5.dirname(dstpath);
1643
- const dirExists = fs2.existsSync(dir);
1644
- if (dirExists) return fs2.linkSync(srcpath, dstpath);
1642
+ const dir = path6.dirname(dstpath);
1643
+ const dirExists = fs3.existsSync(dir);
1644
+ if (dirExists) return fs3.linkSync(srcpath, dstpath);
1645
1645
  mkdir.mkdirsSync(dir);
1646
- return fs2.linkSync(srcpath, dstpath);
1646
+ return fs3.linkSync(srcpath, dstpath);
1647
1647
  }
1648
1648
  module.exports = {
1649
1649
  createLink: u(createLink),
@@ -1656,14 +1656,14 @@ var require_link = __commonJS({
1656
1656
  var require_symlink_paths = __commonJS({
1657
1657
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module) {
1658
1658
  "use strict";
1659
- var path5 = __require("path");
1660
- var fs2 = require_fs();
1659
+ var path6 = __require("path");
1660
+ var fs3 = require_fs();
1661
1661
  var { pathExists } = require_path_exists();
1662
1662
  var u = require_universalify().fromPromise;
1663
1663
  async function symlinkPaths(srcpath, dstpath) {
1664
- if (path5.isAbsolute(srcpath)) {
1664
+ if (path6.isAbsolute(srcpath)) {
1665
1665
  try {
1666
- await fs2.lstat(srcpath);
1666
+ await fs3.lstat(srcpath);
1667
1667
  } catch (err) {
1668
1668
  err.message = err.message.replace("lstat", "ensureSymlink");
1669
1669
  throw err;
@@ -1673,8 +1673,8 @@ var require_symlink_paths = __commonJS({
1673
1673
  toDst: srcpath
1674
1674
  };
1675
1675
  }
1676
- const dstdir = path5.dirname(dstpath);
1677
- const relativeToDst = path5.join(dstdir, srcpath);
1676
+ const dstdir = path6.dirname(dstpath);
1677
+ const relativeToDst = path6.join(dstdir, srcpath);
1678
1678
  const exists = await pathExists(relativeToDst);
1679
1679
  if (exists) {
1680
1680
  return {
@@ -1683,39 +1683,39 @@ var require_symlink_paths = __commonJS({
1683
1683
  };
1684
1684
  }
1685
1685
  try {
1686
- await fs2.lstat(srcpath);
1686
+ await fs3.lstat(srcpath);
1687
1687
  } catch (err) {
1688
1688
  err.message = err.message.replace("lstat", "ensureSymlink");
1689
1689
  throw err;
1690
1690
  }
1691
1691
  return {
1692
1692
  toCwd: srcpath,
1693
- toDst: path5.relative(dstdir, srcpath)
1693
+ toDst: path6.relative(dstdir, srcpath)
1694
1694
  };
1695
1695
  }
1696
1696
  function symlinkPathsSync(srcpath, dstpath) {
1697
- if (path5.isAbsolute(srcpath)) {
1698
- const exists2 = fs2.existsSync(srcpath);
1697
+ if (path6.isAbsolute(srcpath)) {
1698
+ const exists2 = fs3.existsSync(srcpath);
1699
1699
  if (!exists2) throw new Error("absolute srcpath does not exist");
1700
1700
  return {
1701
1701
  toCwd: srcpath,
1702
1702
  toDst: srcpath
1703
1703
  };
1704
1704
  }
1705
- const dstdir = path5.dirname(dstpath);
1706
- const relativeToDst = path5.join(dstdir, srcpath);
1707
- const exists = fs2.existsSync(relativeToDst);
1705
+ const dstdir = path6.dirname(dstpath);
1706
+ const relativeToDst = path6.join(dstdir, srcpath);
1707
+ const exists = fs3.existsSync(relativeToDst);
1708
1708
  if (exists) {
1709
1709
  return {
1710
1710
  toCwd: relativeToDst,
1711
1711
  toDst: srcpath
1712
1712
  };
1713
1713
  }
1714
- const srcExists = fs2.existsSync(srcpath);
1714
+ const srcExists = fs3.existsSync(srcpath);
1715
1715
  if (!srcExists) throw new Error("relative srcpath does not exist");
1716
1716
  return {
1717
1717
  toCwd: srcpath,
1718
- toDst: path5.relative(dstdir, srcpath)
1718
+ toDst: path6.relative(dstdir, srcpath)
1719
1719
  };
1720
1720
  }
1721
1721
  module.exports = {
@@ -1729,13 +1729,13 @@ var require_symlink_paths = __commonJS({
1729
1729
  var require_symlink_type = __commonJS({
1730
1730
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module) {
1731
1731
  "use strict";
1732
- var fs2 = require_fs();
1732
+ var fs3 = require_fs();
1733
1733
  var u = require_universalify().fromPromise;
1734
1734
  async function symlinkType(srcpath, type) {
1735
1735
  if (type) return type;
1736
1736
  let stats;
1737
1737
  try {
1738
- stats = await fs2.lstat(srcpath);
1738
+ stats = await fs3.lstat(srcpath);
1739
1739
  } catch {
1740
1740
  return "file";
1741
1741
  }
@@ -1745,7 +1745,7 @@ var require_symlink_type = __commonJS({
1745
1745
  if (type) return type;
1746
1746
  let stats;
1747
1747
  try {
1748
- stats = fs2.lstatSync(srcpath);
1748
+ stats = fs3.lstatSync(srcpath);
1749
1749
  } catch {
1750
1750
  return "file";
1751
1751
  }
@@ -1763,8 +1763,8 @@ var require_symlink = __commonJS({
1763
1763
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/ensure/symlink.js"(exports, module) {
1764
1764
  "use strict";
1765
1765
  var u = require_universalify().fromPromise;
1766
- var path5 = __require("path");
1767
- var fs2 = require_fs();
1766
+ var path6 = __require("path");
1767
+ var fs3 = require_fs();
1768
1768
  var { mkdirs, mkdirsSync } = require_mkdirs();
1769
1769
  var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
1770
1770
  var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -1773,44 +1773,44 @@ var require_symlink = __commonJS({
1773
1773
  async function createSymlink(srcpath, dstpath, type) {
1774
1774
  let stats;
1775
1775
  try {
1776
- stats = await fs2.lstat(dstpath);
1776
+ stats = await fs3.lstat(dstpath);
1777
1777
  } catch {
1778
1778
  }
1779
1779
  if (stats && stats.isSymbolicLink()) {
1780
1780
  const [srcStat, dstStat] = await Promise.all([
1781
- fs2.stat(srcpath),
1782
- fs2.stat(dstpath)
1781
+ fs3.stat(srcpath),
1782
+ fs3.stat(dstpath)
1783
1783
  ]);
1784
1784
  if (areIdentical(srcStat, dstStat)) return;
1785
1785
  }
1786
1786
  const relative = await symlinkPaths(srcpath, dstpath);
1787
1787
  srcpath = relative.toDst;
1788
1788
  const toType = await symlinkType(relative.toCwd, type);
1789
- const dir = path5.dirname(dstpath);
1789
+ const dir = path6.dirname(dstpath);
1790
1790
  if (!await pathExists(dir)) {
1791
1791
  await mkdirs(dir);
1792
1792
  }
1793
- return fs2.symlink(srcpath, dstpath, toType);
1793
+ return fs3.symlink(srcpath, dstpath, toType);
1794
1794
  }
1795
1795
  function createSymlinkSync(srcpath, dstpath, type) {
1796
1796
  let stats;
1797
1797
  try {
1798
- stats = fs2.lstatSync(dstpath);
1798
+ stats = fs3.lstatSync(dstpath);
1799
1799
  } catch {
1800
1800
  }
1801
1801
  if (stats && stats.isSymbolicLink()) {
1802
- const srcStat = fs2.statSync(srcpath);
1803
- const dstStat = fs2.statSync(dstpath);
1802
+ const srcStat = fs3.statSync(srcpath);
1803
+ const dstStat = fs3.statSync(dstpath);
1804
1804
  if (areIdentical(srcStat, dstStat)) return;
1805
1805
  }
1806
1806
  const relative = symlinkPathsSync(srcpath, dstpath);
1807
1807
  srcpath = relative.toDst;
1808
1808
  type = symlinkTypeSync(relative.toCwd, type);
1809
- const dir = path5.dirname(dstpath);
1810
- const exists = fs2.existsSync(dir);
1811
- if (exists) return fs2.symlinkSync(srcpath, dstpath, type);
1809
+ const dir = path6.dirname(dstpath);
1810
+ const exists = fs3.existsSync(dir);
1811
+ if (exists) return fs3.symlinkSync(srcpath, dstpath, type);
1812
1812
  mkdirsSync(dir);
1813
- return fs2.symlinkSync(srcpath, dstpath, type);
1813
+ return fs3.symlinkSync(srcpath, dstpath, type);
1814
1814
  }
1815
1815
  module.exports = {
1816
1816
  createSymlink: u(createSymlink),
@@ -1879,9 +1879,9 @@ var require_jsonfile = __commonJS({
1879
1879
  if (typeof options === "string") {
1880
1880
  options = { encoding: options };
1881
1881
  }
1882
- const fs2 = options.fs || _fs;
1882
+ const fs3 = options.fs || _fs;
1883
1883
  const shouldThrow = "throws" in options ? options.throws : true;
1884
- let data = await universalify.fromCallback(fs2.readFile)(file4, options);
1884
+ let data = await universalify.fromCallback(fs3.readFile)(file4, options);
1885
1885
  data = stripBom(data);
1886
1886
  let obj;
1887
1887
  try {
@@ -1901,10 +1901,10 @@ var require_jsonfile = __commonJS({
1901
1901
  if (typeof options === "string") {
1902
1902
  options = { encoding: options };
1903
1903
  }
1904
- const fs2 = options.fs || _fs;
1904
+ const fs3 = options.fs || _fs;
1905
1905
  const shouldThrow = "throws" in options ? options.throws : true;
1906
1906
  try {
1907
- let content = fs2.readFileSync(file4, options);
1907
+ let content = fs3.readFileSync(file4, options);
1908
1908
  content = stripBom(content);
1909
1909
  return JSON.parse(content, options.reviver);
1910
1910
  } catch (err) {
@@ -1917,15 +1917,15 @@ var require_jsonfile = __commonJS({
1917
1917
  }
1918
1918
  }
1919
1919
  async function _writeFile(file4, obj, options = {}) {
1920
- const fs2 = options.fs || _fs;
1920
+ const fs3 = options.fs || _fs;
1921
1921
  const str = stringify14(obj, options);
1922
- await universalify.fromCallback(fs2.writeFile)(file4, str, options);
1922
+ await universalify.fromCallback(fs3.writeFile)(file4, str, options);
1923
1923
  }
1924
1924
  var writeFile = universalify.fromPromise(_writeFile);
1925
1925
  function writeFileSync(file4, obj, options = {}) {
1926
- const fs2 = options.fs || _fs;
1926
+ const fs3 = options.fs || _fs;
1927
1927
  const str = stringify14(obj, options);
1928
- return fs2.writeFileSync(file4, str, options);
1928
+ return fs3.writeFileSync(file4, str, options);
1929
1929
  }
1930
1930
  var jsonfile = {
1931
1931
  readFile,
@@ -1957,23 +1957,23 @@ var require_output_file = __commonJS({
1957
1957
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/output-file/index.js"(exports, module) {
1958
1958
  "use strict";
1959
1959
  var u = require_universalify().fromPromise;
1960
- var fs2 = require_fs();
1961
- var path5 = __require("path");
1960
+ var fs3 = require_fs();
1961
+ var path6 = __require("path");
1962
1962
  var mkdir = require_mkdirs();
1963
1963
  var pathExists = require_path_exists().pathExists;
1964
1964
  async function outputFile(file4, data, encoding = "utf-8") {
1965
- const dir = path5.dirname(file4);
1965
+ const dir = path6.dirname(file4);
1966
1966
  if (!await pathExists(dir)) {
1967
1967
  await mkdir.mkdirs(dir);
1968
1968
  }
1969
- return fs2.writeFile(file4, data, encoding);
1969
+ return fs3.writeFile(file4, data, encoding);
1970
1970
  }
1971
1971
  function outputFileSync(file4, ...args) {
1972
- const dir = path5.dirname(file4);
1973
- if (!fs2.existsSync(dir)) {
1972
+ const dir = path6.dirname(file4);
1973
+ if (!fs3.existsSync(dir)) {
1974
1974
  mkdir.mkdirsSync(dir);
1975
1975
  }
1976
- fs2.writeFileSync(file4, ...args);
1976
+ fs3.writeFileSync(file4, ...args);
1977
1977
  }
1978
1978
  module.exports = {
1979
1979
  outputFile: u(outputFile),
@@ -2032,8 +2032,8 @@ var require_json = __commonJS({
2032
2032
  var require_move = __commonJS({
2033
2033
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/move/move.js"(exports, module) {
2034
2034
  "use strict";
2035
- var fs2 = require_fs();
2036
- var path5 = __require("path");
2035
+ var fs3 = require_fs();
2036
+ var path6 = __require("path");
2037
2037
  var { copy } = require_copy2();
2038
2038
  var { remove } = require_remove();
2039
2039
  var { mkdirp } = require_mkdirs();
@@ -2043,8 +2043,8 @@ var require_move = __commonJS({
2043
2043
  const overwrite = opts.overwrite || opts.clobber || false;
2044
2044
  const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, "move", opts);
2045
2045
  await stat.checkParentPaths(src, srcStat, dest, "move");
2046
- const destParent = path5.dirname(dest);
2047
- const parsedParentPath = path5.parse(destParent);
2046
+ const destParent = path6.dirname(dest);
2047
+ const parsedParentPath = path6.parse(destParent);
2048
2048
  if (parsedParentPath.root !== destParent) {
2049
2049
  await mkdirp(destParent);
2050
2050
  }
@@ -2059,7 +2059,7 @@ var require_move = __commonJS({
2059
2059
  }
2060
2060
  }
2061
2061
  try {
2062
- await fs2.rename(src, dest);
2062
+ await fs3.rename(src, dest);
2063
2063
  } catch (err) {
2064
2064
  if (err.code !== "EXDEV") {
2065
2065
  throw err;
@@ -2084,8 +2084,8 @@ var require_move = __commonJS({
2084
2084
  var require_move_sync = __commonJS({
2085
2085
  "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/move/move-sync.js"(exports, module) {
2086
2086
  "use strict";
2087
- var fs2 = require_graceful_fs();
2088
- var path5 = __require("path");
2087
+ var fs3 = require_graceful_fs();
2088
+ var path6 = __require("path");
2089
2089
  var copySync = require_copy2().copySync;
2090
2090
  var removeSync = require_remove().removeSync;
2091
2091
  var mkdirpSync = require_mkdirs().mkdirpSync;
@@ -2095,12 +2095,12 @@ var require_move_sync = __commonJS({
2095
2095
  const overwrite = opts.overwrite || opts.clobber || false;
2096
2096
  const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts);
2097
2097
  stat.checkParentPathsSync(src, srcStat, dest, "move");
2098
- if (!isParentRoot(dest)) mkdirpSync(path5.dirname(dest));
2098
+ if (!isParentRoot(dest)) mkdirpSync(path6.dirname(dest));
2099
2099
  return doRename(src, dest, overwrite, isChangingCase);
2100
2100
  }
2101
2101
  function isParentRoot(dest) {
2102
- const parent = path5.dirname(dest);
2103
- const parsedPath = path5.parse(parent);
2102
+ const parent = path6.dirname(dest);
2103
+ const parsedPath = path6.parse(parent);
2104
2104
  return parsedPath.root === parent;
2105
2105
  }
2106
2106
  function doRename(src, dest, overwrite, isChangingCase) {
@@ -2109,12 +2109,12 @@ var require_move_sync = __commonJS({
2109
2109
  removeSync(dest);
2110
2110
  return rename(src, dest, overwrite);
2111
2111
  }
2112
- if (fs2.existsSync(dest)) throw new Error("dest already exists.");
2112
+ if (fs3.existsSync(dest)) throw new Error("dest already exists.");
2113
2113
  return rename(src, dest, overwrite);
2114
2114
  }
2115
2115
  function rename(src, dest, overwrite) {
2116
2116
  try {
2117
- fs2.renameSync(src, dest);
2117
+ fs3.renameSync(src, dest);
2118
2118
  } catch (err) {
2119
2119
  if (err.code !== "EXDEV") throw err;
2120
2120
  return moveAcrossDevice(src, dest, overwrite);
@@ -2213,8 +2213,8 @@ function getMappings(mappings, datamodel) {
2213
2213
 
2214
2214
  // src/generateClient.ts
2215
2215
  var import_fs_extra = __toESM(require_lib());
2216
- import fs from "node:fs/promises";
2217
- import path4 from "node:path";
2216
+ import fs2 from "node:fs/promises";
2217
+ import path5 from "node:path";
2218
2218
  import { overwriteFile } from "@prisma/fetch-engine";
2219
2219
  import {
2220
2220
  assertNever as assertNever3,
@@ -2898,7 +2898,7 @@ var GenericArgsInfo = class {
2898
2898
 
2899
2899
  // src/TSClient/file-generators/ClassFile.ts
2900
2900
  import crypto from "node:crypto";
2901
- import path from "node:path";
2901
+ import path2 from "node:path";
2902
2902
  import { getClientEngineType, pathToPosix } from "@prisma/internals";
2903
2903
  import * as ts5 from "@prisma/ts-builders";
2904
2904
  import ciInfo from "ci-info";
@@ -3427,7 +3427,23 @@ function buildRuntimeDataModel(datamodel, runtimeName) {
3427
3427
  config.runtimeDataModel = JSON.parse(${JSON.stringify(datamodelString)})`;
3428
3428
  }
3429
3429
 
3430
- // src/utils/buildGetWasmModule.ts
3430
+ // src/utils/buildInlineDatasources.ts
3431
+ function buildInlineDatasources(datasources) {
3432
+ return datasources.reduce((acc, ds) => {
3433
+ return acc[ds.name] = buildInlineDatasource(ds), acc;
3434
+ }, {});
3435
+ }
3436
+ function buildInlineDatasource(ds) {
3437
+ if (ds.url.fromEnvVar) {
3438
+ return { url: { fromEnvVar: ds.url.fromEnvVar, value: null } };
3439
+ } else {
3440
+ return { url: { fromEnvVar: null, value: ds.url.value } };
3441
+ }
3442
+ }
3443
+
3444
+ // src/utils/wasm.ts
3445
+ import fs from "node:fs";
3446
+ import path from "node:path";
3431
3447
  import { capitalize as capitalize6 } from "@prisma/client-common";
3432
3448
  import { match } from "ts-pattern";
3433
3449
  function buildDynamicRequireFn() {
@@ -3436,6 +3452,9 @@ function buildDynamicRequireFn() {
3436
3452
  ? Promise.resolve(globalThis.__non_webpack_require__(name))
3437
3453
  : await import(/* webpackIgnore: true */ /* @vite-ignore */ name)`;
3438
3454
  }
3455
+ function usesEdgeWasmRuntime(component, runtimeName) {
3456
+ return runtimeName === "wasm-engine-edge" && component === "engine" || runtimeName === "wasm-compiler-edge" && component === "compiler";
3457
+ }
3439
3458
  function buildGetWasmModule({
3440
3459
  component,
3441
3460
  runtimeName,
@@ -3445,18 +3464,26 @@ function buildGetWasmModule({
3445
3464
  moduleFormat
3446
3465
  }) {
3447
3466
  const capitalizedComponent = capitalize6(component);
3448
- const wasmPathBase = `${runtimeBase}/query_${component}_bg.${activeProvider}`;
3449
- const wasmBindingsPath = `${wasmPathBase}.mjs`;
3450
- const wasmModulePath = `${wasmPathBase}.wasm`;
3467
+ const buildEdgeLoader = usesEdgeWasmRuntime(component, runtimeName);
3468
+ let wasmBindingsPath;
3469
+ let wasmModulePath;
3470
+ if (buildEdgeLoader) {
3471
+ const wasmPathBase = `./query_${component}_bg`;
3472
+ wasmBindingsPath = `${wasmPathBase}.js`;
3473
+ wasmModulePath = `${wasmPathBase}.wasm`;
3474
+ } else {
3475
+ const wasmPathBase = `${runtimeBase}/query_${component}_bg.${activeProvider}`;
3476
+ wasmBindingsPath = `${wasmPathBase}.mjs`;
3477
+ wasmModulePath = `${wasmPathBase}.wasm`;
3478
+ }
3451
3479
  const buildNodeLoader = match(runtimeName).with("library", () => component === "engine" && !!process.env.PRISMA_CLIENT_FORCE_WASM).with("client", () => component === "compiler").otherwise(() => false);
3452
- const buildEdgeLoader = runtimeName === "wasm-engine-edge" && component === "engine" || runtimeName === "wasm-compiler-edge" && component === "compiler";
3453
3480
  if (buildNodeLoader) {
3454
3481
  return `config.${component}Wasm = {
3455
3482
  getRuntime: async () => await import(${JSON.stringify(wasmBindingsPath)}),
3456
3483
 
3457
3484
  getQuery${capitalizedComponent}WasmModule: async () => {
3458
3485
  ${buildDynamicRequireFn()}
3459
-
3486
+
3460
3487
  // Note: we must use dynamic imports here to avoid bundling errors like \`Module parse failed: Unexpected character '' (1:0)\`.
3461
3488
  const { readFile } = await dynamicRequireFn('node:fs/promises')
3462
3489
  ${buildRequire(moduleFormat)}
@@ -3488,19 +3515,30 @@ function buildRequire(moduleFormat) {
3488
3515
  const _require = createRequire(import.meta.url)
3489
3516
  `;
3490
3517
  }
3491
-
3492
- // src/utils/buildInlineDatasources.ts
3493
- function buildInlineDatasources(datasources) {
3494
- return datasources.reduce((acc, ds) => {
3495
- return acc[ds.name] = buildInlineDatasource(ds), acc;
3496
- }, {});
3497
- }
3498
- function buildInlineDatasource(ds) {
3499
- if (ds.url.fromEnvVar) {
3500
- return { url: { fromEnvVar: ds.url.fromEnvVar, value: null } };
3501
- } else {
3502
- return { url: { fromEnvVar: null, value: ds.url.value } };
3518
+ function buildWasmFileMap({ runtimeName, activeProvider }) {
3519
+ const fileMap = {};
3520
+ for (const component of ["engine", "compiler"]) {
3521
+ if (!usesEdgeWasmRuntime(component, runtimeName)) {
3522
+ continue;
3523
+ }
3524
+ const fileNameBase = `query_${component}_bg.${activeProvider}`;
3525
+ const files = {
3526
+ [`query_${component}_bg.wasm`]: `${fileNameBase}.wasm`,
3527
+ [`query_${component}_bg.js`]: `${fileNameBase}.mjs`
3528
+ };
3529
+ for (const [targetFile, sourceFile] of Object.entries(files)) {
3530
+ const bundledLocation = path.join(__dirname, sourceFile);
3531
+ const sourceLocation = path.join(__dirname, "..", "..", "..", "client", "runtime", sourceFile);
3532
+ if (fs.existsSync(bundledLocation)) {
3533
+ fileMap[targetFile] = fs.readFileSync(bundledLocation);
3534
+ } else if (fs.existsSync(sourceLocation)) {
3535
+ fileMap[targetFile] = fs.readFileSync(sourceLocation);
3536
+ } else {
3537
+ throw new Error(`Could not find ${sourceFile} in ${bundledLocation} or ${sourceLocation}`);
3538
+ }
3539
+ }
3503
3540
  }
3541
+ return fileMap;
3504
3542
  }
3505
3543
 
3506
3544
  // src/TSClient/PrismaClient.ts
@@ -3866,7 +3904,7 @@ function clientConfig(context, options) {
3866
3904
  const datasourceFilePath = datasources[0].sourceFilePath;
3867
3905
  const config = {
3868
3906
  generator,
3869
- relativePath: pathToPosix(path.relative(outputDir, path.dirname(datasourceFilePath))),
3907
+ relativePath: pathToPosix(path2.relative(outputDir, path2.dirname(datasourceFilePath))),
3870
3908
  clientVersion: options.clientVersion,
3871
3909
  engineVersion: options.engineVersion,
3872
3910
  datasourceNames: datasources.map((d) => d.name),
@@ -3891,14 +3929,14 @@ ${buildDebugInitialization(edge)}
3891
3929
  }
3892
3930
 
3893
3931
  // src/TSClient/file-generators/ClientFile.ts
3894
- import path3 from "node:path";
3932
+ import path4 from "node:path";
3895
3933
  import { ClientEngineType as ClientEngineType2, getClientEngineType as getClientEngineType2 } from "@prisma/internals";
3896
3934
  import * as ts6 from "@prisma/ts-builders";
3897
3935
 
3898
3936
  // src/utils/buildNFTAnnotations.ts
3899
3937
  import { getNodeAPIName } from "@prisma/get-platform";
3900
3938
  import { ClientEngineType, parseAWSNodejsRuntimeEnvVarVersion, pathToPosix as pathToPosix2 } from "@prisma/internals";
3901
- import path2 from "path";
3939
+ import path3 from "path";
3902
3940
  function buildNFTAnnotations(noEngine, engineType, binaryTargets, relativeOutdir) {
3903
3941
  if (noEngine === true) return "";
3904
3942
  if (binaryTargets === void 0) {
@@ -3931,7 +3969,7 @@ function getQueryEngineFilename(engineType, binaryTarget) {
3931
3969
  return void 0;
3932
3970
  }
3933
3971
  function buildNFTAnnotation(fileName, relativeOutdir) {
3934
- const relativeFilePath = path2.join(relativeOutdir, fileName);
3972
+ const relativeFilePath = path3.join(relativeOutdir, fileName);
3935
3973
  return `
3936
3974
  // file annotations for bundling tools to include these files
3937
3975
  path.join(__dirname, ${JSON.stringify(pathToPosix2(fileName))})
@@ -3993,7 +4031,7 @@ function createClientFile(context, options) {
3993
4031
  ].join("\n");
3994
4032
  });
3995
4033
  const binaryTargets = clientEngineType === ClientEngineType2.Library ? Object.keys(options.binaryPaths.libqueryEngine ?? {}) : Object.keys(options.binaryPaths.queryEngine ?? {});
3996
- const relativeOutdir = path3.relative(process.cwd(), options.outputDir);
4034
+ const relativeOutdir = path4.relative(process.cwd(), options.outputDir);
3997
4035
  return `${jsDocHeader2}
3998
4036
  ${buildPreamble(options.edge, options.moduleFormat)}
3999
4037
  ${imports.join("\n")}
@@ -6132,12 +6170,13 @@ var generatedCodePreamble = `
6132
6170
  `;
6133
6171
  var tsNoCheckPreamble = `// @ts-nocheck
6134
6172
  `;
6135
- function addPreambleToTSFiles(fileMap, includeTSNoCheckPreamble) {
6173
+ var extensions = [".ts", ".cts", ".mts", ".js", ".cjs", ".mjs"];
6174
+ function addPreambleToSourceFiles(fileMap, includeTSNoCheckPreamble) {
6136
6175
  for (const [key, value] of Object.entries(fileMap)) {
6137
- if (typeof value === "string" && (key.endsWith(".ts") || key.endsWith(".cts") || key.endsWith(".mts"))) {
6138
- fileMap[key] = generatedCodePreamble + (includeTSNoCheckPreamble ? tsNoCheckPreamble : "") + value;
6139
- } else if (typeof value === "object" && value !== null) {
6140
- addPreambleToTSFiles(value, includeTSNoCheckPreamble);
6176
+ if ((typeof value === "string" || Buffer.isBuffer(value)) && extensions.some((ext) => key.endsWith(ext))) {
6177
+ fileMap[key] = generatedCodePreamble + (includeTSNoCheckPreamble ? tsNoCheckPreamble : "") + value.toString();
6178
+ } else if (typeof value === "object" && value !== null && !Buffer.isBuffer(value)) {
6179
+ addPreambleToSourceFiles(value, includeTSNoCheckPreamble);
6141
6180
  }
6142
6181
  }
6143
6182
  }
@@ -6217,7 +6256,17 @@ function buildClient({
6217
6256
  })
6218
6257
  };
6219
6258
  }
6220
- addPreambleToTSFiles(fileMap, tsNoCheckPreamble2);
6259
+ fileMap = {
6260
+ ...fileMap,
6261
+ internal: {
6262
+ ...fileMap.internal,
6263
+ ...buildWasmFileMap({
6264
+ runtimeName,
6265
+ activeProvider
6266
+ })
6267
+ }
6268
+ };
6269
+ addPreambleToSourceFiles(fileMap, tsNoCheckPreamble2);
6221
6270
  return {
6222
6271
  fileMap,
6223
6272
  // a map of file names to their contents
@@ -6304,12 +6353,12 @@ To learn more about how to rename models, check out https://pris.ly/d/naming-mod
6304
6353
  await (0, import_fs_extra.ensureDir)("/tmp/prisma-engines");
6305
6354
  }
6306
6355
  for (const [binaryTarget, filePath] of Object.entries(enginePath)) {
6307
- const fileName = path4.basename(filePath);
6356
+ const fileName = path5.basename(filePath);
6308
6357
  let target2;
6309
6358
  if (process.env.NETLIFY && !["rhel-openssl-1.0.x", "rhel-openssl-3.0.x"].includes(binaryTarget)) {
6310
- target2 = path4.join("/tmp/prisma-engines", fileName);
6359
+ target2 = path5.join("/tmp/prisma-engines", fileName);
6311
6360
  } else {
6312
- target2 = path4.join(outputDir, fileName);
6361
+ target2 = path5.join(outputDir, fileName);
6313
6362
  }
6314
6363
  await overwriteFile(filePath, target2);
6315
6364
  }
@@ -6318,12 +6367,12 @@ To learn more about how to rename models, check out https://pris.ly/d/naming-mod
6318
6367
  function writeFileMap(outputDir, fileMap) {
6319
6368
  return Promise.all(
6320
6369
  Object.entries(fileMap).map(async ([fileName, content]) => {
6321
- const absolutePath = path4.join(outputDir, fileName);
6322
- await fs.rm(absolutePath, { recursive: true, force: true });
6323
- if (typeof content === "string") {
6324
- await fs.writeFile(absolutePath, content);
6370
+ const absolutePath = path5.join(outputDir, fileName);
6371
+ await fs2.rm(absolutePath, { recursive: true, force: true });
6372
+ if (typeof content === "string" || Buffer.isBuffer(content)) {
6373
+ await fs2.writeFile(absolutePath, content);
6325
6374
  } else {
6326
- await fs.mkdir(absolutePath);
6375
+ await fs2.mkdir(absolutePath);
6327
6376
  await writeFileMap(absolutePath, content);
6328
6377
  }
6329
6378
  })
@@ -6407,10 +6456,10 @@ function validateDmmfAgainstDenylists(prismaClientDmmf) {
6407
6456
  return errorArray.length > 0 ? errorArray : null;
6408
6457
  }
6409
6458
  async function getGenerationDirs({ runtimeBase, outputDir }) {
6410
- const normalizedOutputDir = path4.normalize(outputDir);
6459
+ const normalizedOutputDir = path5.normalize(outputDir);
6411
6460
  const normalizedRuntimeBase = pathToPosix3(runtimeBase);
6412
- const userPackageRoot = await pkgUp({ cwd: path4.dirname(normalizedOutputDir) });
6413
- const userProjectRoot = userPackageRoot ? path4.dirname(userPackageRoot) : process.cwd();
6461
+ const userPackageRoot = await pkgUp({ cwd: path5.dirname(normalizedOutputDir) });
6462
+ const userProjectRoot = userPackageRoot ? path5.dirname(userPackageRoot) : process.cwd();
6414
6463
  return {
6415
6464
  runtimeBase: normalizedRuntimeBase,
6416
6465
  outputDir: normalizedOutputDir,
@@ -6451,7 +6500,7 @@ function getNodeRuntimeName(engineType) {
6451
6500
  }
6452
6501
  async function deleteOutputDir(outputDir) {
6453
6502
  try {
6454
- const files = await fs.readdir(outputDir);
6503
+ const files = await fs2.readdir(outputDir);
6455
6504
  if (files.length === 0) {
6456
6505
  return;
6457
6506
  }
@@ -6472,7 +6521,7 @@ async function deleteOutputDir(outputDir) {
6472
6521
  {
6473
6522
  followSymbolicLinks: false
6474
6523
  }
6475
- )).map((file4) => fs.unlink(file4))
6524
+ )).map((file4) => fs2.unlink(file4))
6476
6525
  );
6477
6526
  } catch (error) {
6478
6527
  if (error.code !== "ENOENT") {
@@ -6489,7 +6538,7 @@ import { getTsconfig } from "get-tsconfig";
6489
6538
  import { match as match2 } from "ts-pattern";
6490
6539
 
6491
6540
  // package.json
6492
- var version = "6.12.0-dev.32";
6541
+ var version = "6.12.0-dev.34";
6493
6542
 
6494
6543
  // src/module-format.ts
6495
6544
  function parseModuleFormat(format) {