Erster Docker-Stand

_node_modules/@prisma/get-platform/dist/binaryTargets.d.ts

@@ -0,0 +1,2 @@
+export type BinaryTarget = 'native' | 'darwin' | 'darwin-arm64' | 'debian-openssl-1.0.x' | 'debian-openssl-1.1.x' | 'debian-openssl-3.0.x' | 'rhel-openssl-1.0.x' | 'rhel-openssl-1.1.x' | 'rhel-openssl-3.0.x' | 'linux-arm64-openssl-1.1.x' | 'linux-arm64-openssl-1.0.x' | 'linux-arm64-openssl-3.0.x' | 'linux-arm-openssl-1.1.x' | 'linux-arm-openssl-1.0.x' | 'linux-arm-openssl-3.0.x' | 'linux-musl' | 'linux-musl-openssl-3.0.x' | 'linux-musl-arm64-openssl-1.1.x' | 'linux-musl-arm64-openssl-3.0.x' | 'linux-nixos' | 'linux-static-x64' | 'linux-static-arm64' | 'windows' | 'freebsd11' | 'freebsd12' | 'freebsd13' | 'freebsd14' | 'freebsd15' | 'openbsd' | 'netbsd' | 'arm';
+export declare const binaryTargets: BinaryTarget[];

_node_modules/@prisma/get-platform/dist/binaryTargets.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var binaryTargets_exports = {};
+__export(binaryTargets_exports, {
+  binaryTargets: () => import_chunk_7MLUNQIZ.binaryTargets
+});
+module.exports = __toCommonJS(binaryTargets_exports);
+var import_chunk_7MLUNQIZ = require("./chunk-7MLUNQIZ.js");
+var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");
+(0, import_chunk_7MLUNQIZ.init_binaryTargets)();

_node_modules/@prisma/get-platform/dist/chunk-2ESYSVXG.js

@@ -0,0 +1,67 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_2ESYSVXG_exports = {};
+__export(chunk_2ESYSVXG_exports, {
+  __commonJS: () => __commonJS,
+  __esm: () => __esm,
+  __export: () => __export2,
+  __require: () => __require,
+  __toCommonJS: () => __toCommonJS2,
+  __toESM: () => __toESM
+});
+module.exports = __toCommonJS(chunk_2ESYSVXG_exports);
+var __create = Object.create;
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export2 = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps2 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames2(from))
+      if (!__hasOwnProp2.call(to, key) && key !== except)
+        __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps2(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);

_node_modules/@prisma/get-platform/dist/chunk-6HZWON4S.js

@@ -0,0 +1 @@
+"use strict";

_node_modules/@prisma/get-platform/dist/chunk-7MLUNQIZ.js

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_7MLUNQIZ_exports = {};
+__export(chunk_7MLUNQIZ_exports, {
+  binaryTargets: () => binaryTargets,
+  init_binaryTargets: () => init_binaryTargets
+});
+module.exports = __toCommonJS(chunk_7MLUNQIZ_exports);
+var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");
+var binaryTargets;
+var init_binaryTargets = (0, import_chunk_2ESYSVXG.__esm)({
+  "src/binaryTargets.ts"() {
+    binaryTargets = [
+      "darwin",
+      "darwin-arm64",
+      "debian-openssl-1.0.x",
+      "debian-openssl-1.1.x",
+      "debian-openssl-3.0.x",
+      "rhel-openssl-1.0.x",
+      "rhel-openssl-1.1.x",
+      "rhel-openssl-3.0.x",
+      "linux-arm64-openssl-1.1.x",
+      "linux-arm64-openssl-1.0.x",
+      "linux-arm64-openssl-3.0.x",
+      "linux-arm-openssl-1.1.x",
+      "linux-arm-openssl-1.0.x",
+      "linux-arm-openssl-3.0.x",
+      "linux-musl",
+      "linux-musl-openssl-3.0.x",
+      "linux-musl-arm64-openssl-1.1.x",
+      "linux-musl-arm64-openssl-3.0.x",
+      "linux-nixos",
+      "linux-static-x64",
+      "linux-static-arm64",
+      "windows",
+      "freebsd11",
+      "freebsd12",
+      "freebsd13",
+      "freebsd14",
+      "freebsd15",
+      "openbsd",
+      "netbsd",
+      "arm"
+    ];
+  }
+});

_node_modules/@prisma/get-platform/dist/chunk-7PMGXL6S.js

@@ -0,0 +1,585 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_7PMGXL6S_exports = {};
+__export(chunk_7PMGXL6S_exports, {
+  computeLibSSLSpecificPaths: () => computeLibSSLSpecificPaths,
+  getArchFromUname: () => getArchFromUname,
+  getBinaryTargetForCurrentPlatform: () => getBinaryTargetForCurrentPlatform,
+  getBinaryTargetForCurrentPlatformInternal: () => getBinaryTargetForCurrentPlatformInternal,
+  getPlatformInfo: () => getPlatformInfo,
+  getPlatformInfoMemoized: () => getPlatformInfoMemoized,
+  getSSLVersion: () => getSSLVersion,
+  getos: () => getos,
+  parseDistro: () => parseDistro,
+  parseLibSSLVersion: () => parseLibSSLVersion,
+  parseOpenSSLVersion: () => parseOpenSSLVersion,
+  resolveDistro: () => resolveDistro
+});
+module.exports = __toCommonJS(chunk_7PMGXL6S_exports);
+var import_chunk_FWMN4WME = require("./chunk-FWMN4WME.js");
+var import_debug = __toESM(require("@prisma/debug"));
+var import_child_process = __toESM(require("child_process"));
+var import_promises = __toESM(require("fs/promises"));
+var import_os = __toESM(require("os"));
+var import_util = require("util");
+var t = Symbol.for("@ts-pattern/matcher");
+var e = Symbol.for("@ts-pattern/isVariadic");
+var n = "@ts-pattern/anonymous-select-key";
+var r = (t2) => Boolean(t2 && "object" == typeof t2);
+var i = (e2) => e2 && !!e2[t];
+var s = (n2, o2, c2) => {
+  if (i(n2)) {
+    const e2 = n2[t](), { matched: r2, selections: i2 } = e2.match(o2);
+    return r2 && i2 && Object.keys(i2).forEach((t2) => c2(t2, i2[t2])), r2;
+  }
+  if (r(n2)) {
+    if (!r(o2)) return false;
+    if (Array.isArray(n2)) {
+      if (!Array.isArray(o2)) return false;
+      let t2 = [], r2 = [], a = [];
+      for (const s2 of n2.keys()) {
+        const o3 = n2[s2];
+        i(o3) && o3[e] ? a.push(o3) : a.length ? r2.push(o3) : t2.push(o3);
+      }
+      if (a.length) {
+        if (a.length > 1) throw new Error("Pattern error: Using `...P.array(...)` several times in a single pattern is not allowed.");
+        if (o2.length < t2.length + r2.length) return false;
+        const e2 = o2.slice(0, t2.length), n3 = 0 === r2.length ? [] : o2.slice(-r2.length), i2 = o2.slice(t2.length, 0 === r2.length ? Infinity : -r2.length);
+        return t2.every((t3, n4) => s(t3, e2[n4], c2)) && r2.every((t3, e3) => s(t3, n3[e3], c2)) && (0 === a.length || s(a[0], i2, c2));
+      }
+      return n2.length === o2.length && n2.every((t3, e2) => s(t3, o2[e2], c2));
+    }
+    return Reflect.ownKeys(n2).every((e2) => {
+      const r2 = n2[e2];
+      return (e2 in o2 || i(a = r2) && "optional" === a[t]().matcherType) && s(r2, o2[e2], c2);
+      var a;
+    });
+  }
+  return Object.is(o2, n2);
+};
+var o = (e2) => {
+  var n2, s2, a;
+  return r(e2) ? i(e2) ? null != (n2 = null == (s2 = (a = e2[t]()).getSelectionKeys) ? void 0 : s2.call(a)) ? n2 : [] : Array.isArray(e2) ? c(e2, o) : c(Object.values(e2), o) : [];
+};
+var c = (t2, e2) => t2.reduce((t3, n2) => t3.concat(e2(n2)), []);
+function u(t2) {
+  return Object.assign(t2, { optional: () => h(t2), and: (e2) => m(t2, e2), or: (e2) => d(t2, e2), select: (e2) => void 0 === e2 ? y(t2) : y(e2, t2) });
+}
+function h(e2) {
+  return u({ [t]: () => ({ match: (t2) => {
+    let n2 = {};
+    const r2 = (t3, e3) => {
+      n2[t3] = e3;
+    };
+    return void 0 === t2 ? (o(e2).forEach((t3) => r2(t3, void 0)), { matched: true, selections: n2 }) : { matched: s(e2, t2, r2), selections: n2 };
+  }, getSelectionKeys: () => o(e2), matcherType: "optional" }) });
+}
+function m(...e2) {
+  return u({ [t]: () => ({ match: (t2) => {
+    let n2 = {};
+    const r2 = (t3, e3) => {
+      n2[t3] = e3;
+    };
+    return { matched: e2.every((e3) => s(e3, t2, r2)), selections: n2 };
+  }, getSelectionKeys: () => c(e2, o), matcherType: "and" }) });
+}
+function d(...e2) {
+  return u({ [t]: () => ({ match: (t2) => {
+    let n2 = {};
+    const r2 = (t3, e3) => {
+      n2[t3] = e3;
+    };
+    return c(e2, o).forEach((t3) => r2(t3, void 0)), { matched: e2.some((e3) => s(e3, t2, r2)), selections: n2 };
+  }, getSelectionKeys: () => c(e2, o), matcherType: "or" }) });
+}
+function p(e2) {
+  return { [t]: () => ({ match: (t2) => ({ matched: Boolean(e2(t2)) }) }) };
+}
+function y(...e2) {
+  const r2 = "string" == typeof e2[0] ? e2[0] : void 0, i2 = 2 === e2.length ? e2[1] : "string" == typeof e2[0] ? void 0 : e2[0];
+  return u({ [t]: () => ({ match: (t2) => {
+    let e3 = { [null != r2 ? r2 : n]: t2 };
+    return { matched: void 0 === i2 || s(i2, t2, (t3, n2) => {
+      e3[t3] = n2;
+    }), selections: e3 };
+  }, getSelectionKeys: () => [null != r2 ? r2 : n].concat(void 0 === i2 ? [] : o(i2)) }) });
+}
+function v(t2) {
+  return "number" == typeof t2;
+}
+function b(t2) {
+  return "string" == typeof t2;
+}
+function w(t2) {
+  return "bigint" == typeof t2;
+}
+var S = u(p(function(t2) {
+  return true;
+}));
+var j = (t2) => Object.assign(u(t2), { startsWith: (e2) => {
+  return j(m(t2, (n2 = e2, p((t3) => b(t3) && t3.startsWith(n2)))));
+  var n2;
+}, endsWith: (e2) => {
+  return j(m(t2, (n2 = e2, p((t3) => b(t3) && t3.endsWith(n2)))));
+  var n2;
+}, minLength: (e2) => j(m(t2, ((t3) => p((e3) => b(e3) && e3.length >= t3))(e2))), length: (e2) => j(m(t2, ((t3) => p((e3) => b(e3) && e3.length === t3))(e2))), maxLength: (e2) => j(m(t2, ((t3) => p((e3) => b(e3) && e3.length <= t3))(e2))), includes: (e2) => {
+  return j(m(t2, (n2 = e2, p((t3) => b(t3) && t3.includes(n2)))));
+  var n2;
+}, regex: (e2) => {
+  return j(m(t2, (n2 = e2, p((t3) => b(t3) && Boolean(t3.match(n2))))));
+  var n2;
+} });
+var K = j(p(b));
+var x = (t2) => Object.assign(u(t2), { between: (e2, n2) => x(m(t2, ((t3, e3) => p((n3) => v(n3) && t3 <= n3 && e3 >= n3))(e2, n2))), lt: (e2) => x(m(t2, ((t3) => p((e3) => v(e3) && e3 < t3))(e2))), gt: (e2) => x(m(t2, ((t3) => p((e3) => v(e3) && e3 > t3))(e2))), lte: (e2) => x(m(t2, ((t3) => p((e3) => v(e3) && e3 <= t3))(e2))), gte: (e2) => x(m(t2, ((t3) => p((e3) => v(e3) && e3 >= t3))(e2))), int: () => x(m(t2, p((t3) => v(t3) && Number.isInteger(t3)))), finite: () => x(m(t2, p((t3) => v(t3) && Number.isFinite(t3)))), positive: () => x(m(t2, p((t3) => v(t3) && t3 > 0))), negative: () => x(m(t2, p((t3) => v(t3) && t3 < 0))) });
+var E = x(p(v));
+var A = (t2) => Object.assign(u(t2), { between: (e2, n2) => A(m(t2, ((t3, e3) => p((n3) => w(n3) && t3 <= n3 && e3 >= n3))(e2, n2))), lt: (e2) => A(m(t2, ((t3) => p((e3) => w(e3) && e3 < t3))(e2))), gt: (e2) => A(m(t2, ((t3) => p((e3) => w(e3) && e3 > t3))(e2))), lte: (e2) => A(m(t2, ((t3) => p((e3) => w(e3) && e3 <= t3))(e2))), gte: (e2) => A(m(t2, ((t3) => p((e3) => w(e3) && e3 >= t3))(e2))), positive: () => A(m(t2, p((t3) => w(t3) && t3 > 0))), negative: () => A(m(t2, p((t3) => w(t3) && t3 < 0))) });
+var P = A(p(w));
+var T = u(p(function(t2) {
+  return "boolean" == typeof t2;
+}));
+var B = u(p(function(t2) {
+  return "symbol" == typeof t2;
+}));
+var _ = u(p(function(t2) {
+  return null == t2;
+}));
+var k = u(p(function(t2) {
+  return null != t2;
+}));
+var W = class extends Error {
+  constructor(t2) {
+    let e2;
+    try {
+      e2 = JSON.stringify(t2);
+    } catch (n2) {
+      e2 = t2;
+    }
+    super(`Pattern matching error: no pattern matches value ${e2}`), this.input = void 0, this.input = t2;
+  }
+};
+var $ = { matched: false, value: void 0 };
+function z(t2) {
+  return new I(t2, $);
+}
+var I = class _I {
+  constructor(t2, e2) {
+    this.input = void 0, this.state = void 0, this.input = t2, this.state = e2;
+  }
+  with(...t2) {
+    if (this.state.matched) return this;
+    const e2 = t2[t2.length - 1], r2 = [t2[0]];
+    let i2;
+    3 === t2.length && "function" == typeof t2[1] ? i2 = t2[1] : t2.length > 2 && r2.push(...t2.slice(1, t2.length - 1));
+    let o2 = false, c2 = {};
+    const a = (t3, e3) => {
+      o2 = true, c2[t3] = e3;
+    }, u2 = !r2.some((t3) => s(t3, this.input, a)) || i2 && !Boolean(i2(this.input)) ? $ : { matched: true, value: e2(o2 ? n in c2 ? c2[n] : c2 : this.input, this.input) };
+    return new _I(this.input, u2);
+  }
+  when(t2, e2) {
+    if (this.state.matched) return this;
+    const n2 = Boolean(t2(this.input));
+    return new _I(this.input, n2 ? { matched: true, value: e2(this.input, this.input) } : $);
+  }
+  otherwise(t2) {
+    return this.state.matched ? this.state.value : t2(this.input);
+  }
+  exhaustive() {
+    if (this.state.matched) return this.state.value;
+    throw new W(this.input);
+  }
+  run() {
+    return this.exhaustive();
+  }
+  returnType() {
+    return this;
+  }
+};
+var exec = (0, import_util.promisify)(import_child_process.default.exec);
+var debug = (0, import_debug.default)("prisma:get-platform");
+var supportedLibSSLVersions = ["1.0.x", "1.1.x", "3.0.x"];
+async function getos() {
+  const platform = import_os.default.platform();
+  const arch = process.arch;
+  if (platform === "freebsd") {
+    const version = await getCommandOutput(`freebsd-version`);
+    if (version && version.trim().length > 0) {
+      const regex = /^(\d+)\.?/;
+      const match = regex.exec(version);
+      if (match) {
+        return {
+          platform: "freebsd",
+          targetDistro: `freebsd${match[1]}`,
+          arch
+        };
+      }
+    }
+  }
+  if (platform !== "linux") {
+    return {
+      platform,
+      arch
+    };
+  }
+  const distroInfo = await resolveDistro();
+  const archFromUname = await getArchFromUname();
+  const libsslSpecificPaths = computeLibSSLSpecificPaths({ arch, archFromUname, familyDistro: distroInfo.familyDistro });
+  const { libssl } = await getSSLVersion(libsslSpecificPaths);
+  return {
+    platform: "linux",
+    libssl,
+    arch,
+    archFromUname,
+    ...distroInfo
+  };
+}
+function parseDistro(osReleaseInput) {
+  const idRegex = /^ID="?([^"\n]*)"?$/im;
+  const idLikeRegex = /^ID_LIKE="?([^"\n]*)"?$/im;
+  const idMatch = idRegex.exec(osReleaseInput);
+  const id = idMatch && idMatch[1] && idMatch[1].toLowerCase() || "";
+  const idLikeMatch = idLikeRegex.exec(osReleaseInput);
+  const idLike = idLikeMatch && idLikeMatch[1] && idLikeMatch[1].toLowerCase() || "";
+  const distroInfo = z({ id, idLike }).with(
+    { id: "alpine" },
+    ({ id: originalDistro }) => ({
+      targetDistro: "musl",
+      familyDistro: originalDistro,
+      originalDistro
+    })
+  ).with(
+    { id: "raspbian" },
+    ({ id: originalDistro }) => ({
+      targetDistro: "arm",
+      familyDistro: "debian",
+      originalDistro
+    })
+  ).with(
+    { id: "nixos" },
+    ({ id: originalDistro }) => ({
+      targetDistro: "nixos",
+      originalDistro,
+      familyDistro: "nixos"
+    })
+  ).with(
+    { id: "debian" },
+    { id: "ubuntu" },
+    ({ id: originalDistro }) => ({
+      targetDistro: "debian",
+      familyDistro: "debian",
+      originalDistro
+    })
+  ).with(
+    { id: "rhel" },
+    { id: "centos" },
+    { id: "fedora" },
+    ({ id: originalDistro }) => ({
+      targetDistro: "rhel",
+      familyDistro: "rhel",
+      originalDistro
+    })
+  ).when(
+    ({ idLike: idLike2 }) => idLike2.includes("debian") || idLike2.includes("ubuntu"),
+    ({ id: originalDistro }) => ({
+      targetDistro: "debian",
+      familyDistro: "debian",
+      originalDistro
+    })
+  ).when(
+    ({ idLike: idLike2 }) => id === "arch" || idLike2.includes("arch"),
+    ({ id: originalDistro }) => ({
+      targetDistro: "debian",
+      familyDistro: "arch",
+      originalDistro
+    })
+  ).when(
+    ({ idLike: idLike2 }) => idLike2.includes("centos") || idLike2.includes("fedora") || idLike2.includes("rhel") || idLike2.includes("suse"),
+    ({ id: originalDistro }) => ({
+      targetDistro: "rhel",
+      familyDistro: "rhel",
+      originalDistro
+    })
+  ).otherwise(({ id: originalDistro }) => {
+    return {
+      targetDistro: void 0,
+      familyDistro: void 0,
+      originalDistro
+    };
+  });
+  debug(`Found distro info:
+${JSON.stringify(distroInfo, null, 2)}`);
+  return distroInfo;
+}
+async function resolveDistro() {
+  const osReleaseFile = "/etc/os-release";
+  try {
+    const osReleaseInput = await import_promises.default.readFile(osReleaseFile, { encoding: "utf-8" });
+    return parseDistro(osReleaseInput);
+  } catch (_2) {
+    return {
+      targetDistro: void 0,
+      familyDistro: void 0,
+      originalDistro: void 0
+    };
+  }
+}
+function parseOpenSSLVersion(input) {
+  const match = /^OpenSSL\s(\d+\.\d+)\.\d+/.exec(input);
+  if (match) {
+    const partialVersion = `${match[1]}.x`;
+    return sanitiseSSLVersion(partialVersion);
+  }
+  return void 0;
+}
+function parseLibSSLVersion(input) {
+  const match = /libssl\.so\.(\d)(\.\d)?/.exec(input);
+  if (match) {
+    const partialVersion = `${match[1]}${match[2] ?? ".0"}.x`;
+    return sanitiseSSLVersion(partialVersion);
+  }
+  return void 0;
+}
+function sanitiseSSLVersion(version) {
+  const sanitisedVersion = (() => {
+    if (isLibssl1x(version)) {
+      return version;
+    }
+    const versionSplit = version.split(".");
+    versionSplit[1] = "0";
+    return versionSplit.join(".");
+  })();
+  if (supportedLibSSLVersions.includes(sanitisedVersion)) {
+    return sanitisedVersion;
+  }
+  return void 0;
+}
+function computeLibSSLSpecificPaths(args) {
+  return z(args).with({ familyDistro: "musl" }, () => {
+    debug('Trying platform-specific paths for "alpine"');
+    return ["/lib", "/usr/lib"];
+  }).with({ familyDistro: "debian" }, ({ archFromUname }) => {
+    debug('Trying platform-specific paths for "debian" (and "ubuntu")');
+    return [`/usr/lib/${archFromUname}-linux-gnu`, `/lib/${archFromUname}-linux-gnu`];
+  }).with({ familyDistro: "rhel" }, () => {
+    debug('Trying platform-specific paths for "rhel"');
+    return ["/lib64", "/usr/lib64"];
+  }).otherwise(({ familyDistro, arch, archFromUname }) => {
+    debug(`Don't know any platform-specific paths for "${familyDistro}" on ${arch} (${archFromUname})`);
+    return [];
+  });
+}
+async function getSSLVersion(libsslSpecificPaths) {
+  const excludeLibssl0x = 'grep -v "libssl.so.0"';
+  const libsslFilenameFromSpecificPath = await findLibSSLInLocations(libsslSpecificPaths);
+  if (libsslFilenameFromSpecificPath) {
+    debug(`Found libssl.so file using platform-specific paths: ${libsslFilenameFromSpecificPath}`);
+    const libsslVersion = parseLibSSLVersion(libsslFilenameFromSpecificPath);
+    debug(`The parsed libssl version is: ${libsslVersion}`);
+    if (libsslVersion) {
+      return { libssl: libsslVersion, strategy: "libssl-specific-path" };
+    }
+  }
+  debug('Falling back to "ldconfig" and other generic paths');
+  let libsslFilename = await getCommandOutput(
+    /**
+     * The `ldconfig -p` returns the dynamic linker cache paths, where libssl.so files are likely to be included.
+     * Each line looks like this:
+     * 	libssl.so (libc6,hard-float) => /usr/lib/arm-linux-gnueabihf/libssl.so.1.1
+     * But we're only interested in the filename, so we use sed to remove everything before the `=>` separator,
+     * and then we remove the path and keep only the filename.
+     * The second sed commands uses `|` as a separator because the paths may contain `/`, which would result in the
+     * `unknown option to 's'` error (see https://stackoverflow.com/a/9366940/6174476) - which would silently
+     * fail with error code 0.
+     */
+    `ldconfig -p | sed "s/.*=>s*//" | sed "s|.*/||" | grep libssl | sort | ${excludeLibssl0x}`
+  );
+  if (!libsslFilename) {
+    libsslFilename = await findLibSSLInLocations(["/lib64", "/usr/lib64", "/lib", "/usr/lib"]);
+  }
+  if (libsslFilename) {
+    debug(`Found libssl.so file using "ldconfig" or other generic paths: ${libsslFilename}`);
+    const libsslVersion = parseLibSSLVersion(libsslFilename);
+    debug(`The parsed libssl version is: ${libsslVersion}`);
+    if (libsslVersion) {
+      return { libssl: libsslVersion, strategy: "ldconfig" };
+    }
+  }
+  const openSSLVersionLine = await getCommandOutput("openssl version -v");
+  if (openSSLVersionLine) {
+    debug(`Found openssl binary with version: ${openSSLVersionLine}`);
+    const openSSLVersion = parseOpenSSLVersion(openSSLVersionLine);
+    debug(`The parsed openssl version is: ${openSSLVersion}`);
+    if (openSSLVersion) {
+      return { libssl: openSSLVersion, strategy: "openssl-binary" };
+    }
+  }
+  debug(`Couldn't find any version of libssl or OpenSSL in the system`);
+  return {};
+}
+async function findLibSSLInLocations(directories) {
+  for (const dir of directories) {
+    const libssl = await findLibSSL(dir);
+    if (libssl) {
+      return libssl;
+    }
+  }
+  return void 0;
+}
+async function findLibSSL(directory) {
+  try {
+    const dirContents = await import_promises.default.readdir(directory);
+    return dirContents.find((value) => value.startsWith("libssl.so.") && !value.startsWith("libssl.so.0"));
+  } catch (e2) {
+    if (e2.code === "ENOENT") {
+      return void 0;
+    }
+    throw e2;
+  }
+}
+async function getBinaryTargetForCurrentPlatform() {
+  const { binaryTarget } = await getPlatformInfoMemoized();
+  return binaryTarget;
+}
+function isPlatformInfoDefined(args) {
+  return args.binaryTarget !== void 0;
+}
+async function getPlatformInfo() {
+  const { memoized: _2, ...rest } = await getPlatformInfoMemoized();
+  return rest;
+}
+var memoizedPlatformWithInfo = {};
+async function getPlatformInfoMemoized() {
+  if (isPlatformInfoDefined(memoizedPlatformWithInfo)) {
+    return Promise.resolve({ ...memoizedPlatformWithInfo, memoized: true });
+  }
+  const args = await getos();
+  const binaryTarget = getBinaryTargetForCurrentPlatformInternal(args);
+  memoizedPlatformWithInfo = { ...args, binaryTarget };
+  return { ...memoizedPlatformWithInfo, memoized: false };
+}
+function getBinaryTargetForCurrentPlatformInternal(args) {
+  const { platform, arch, archFromUname, libssl, targetDistro, familyDistro, originalDistro } = args;
+  if (platform === "linux" && !["x64", "arm64"].includes(arch)) {
+    (0, import_chunk_FWMN4WME.warn)(
+      `Prisma only officially supports Linux on amd64 (x86_64) and arm64 (aarch64) system architectures (detected "${arch}" instead). If you are using your own custom Prisma engines, you can ignore this warning, as long as you've compiled the engines for your system architecture "${archFromUname}".`
+    );
+  }
+  const defaultLibssl = "1.1.x";
+  if (platform === "linux" && libssl === void 0) {
+    const additionalMessage = z({ familyDistro }).with({ familyDistro: "debian" }, () => {
+      return "Please manually install OpenSSL via `apt-get update -y && apt-get install -y openssl` and try installing Prisma again. If you're running Prisma on Docker, add this command to your Dockerfile, or switch to an image that already has OpenSSL installed.";
+    }).otherwise(() => {
+      return "Please manually install OpenSSL and try installing Prisma again.";
+    });
+    (0, import_chunk_FWMN4WME.warn)(
+      `Prisma failed to detect the libssl/openssl version to use, and may not work as expected. Defaulting to "openssl-${defaultLibssl}".
+${additionalMessage}`
+    );
+  }
+  const defaultDistro = "debian";
+  if (platform === "linux" && targetDistro === void 0) {
+    debug(`Distro is "${originalDistro}". Falling back to Prisma engines built for "${defaultDistro}".`);
+  }
+  if (platform === "darwin" && arch === "arm64") {
+    return "darwin-arm64";
+  }
+  if (platform === "darwin") {
+    return "darwin";
+  }
+  if (platform === "win32") {
+    return "windows";
+  }
+  if (platform === "freebsd") {
+    return targetDistro;
+  }
+  if (platform === "openbsd") {
+    return "openbsd";
+  }
+  if (platform === "netbsd") {
+    return "netbsd";
+  }
+  if (platform === "linux" && targetDistro === "nixos") {
+    return "linux-nixos";
+  }
+  if (platform === "linux" && arch === "arm64") {
+    const baseName = targetDistro === "musl" ? "linux-musl-arm64" : "linux-arm64";
+    return `${baseName}-openssl-${libssl || defaultLibssl}`;
+  }
+  if (platform === "linux" && arch === "arm") {
+    return `linux-arm-openssl-${libssl || defaultLibssl}`;
+  }
+  if (platform === "linux" && targetDistro === "musl") {
+    const base = "linux-musl";
+    if (!libssl) {
+      return base;
+    }
+    if (isLibssl1x(libssl)) {
+      return base;
+    } else {
+      return `${base}-openssl-${libssl}`;
+    }
+  }
+  if (platform === "linux" && targetDistro && libssl) {
+    return `${targetDistro}-openssl-${libssl}`;
+  }
+  if (platform !== "linux") {
+    (0, import_chunk_FWMN4WME.warn)(`Prisma detected unknown OS "${platform}" and may not work as expected. Defaulting to "linux".`);
+  }
+  if (libssl) {
+    return `${defaultDistro}-openssl-${libssl}`;
+  }
+  if (targetDistro) {
+    return `${targetDistro}-openssl-${defaultLibssl}`;
+  }
+  return `${defaultDistro}-openssl-${defaultLibssl}`;
+}
+async function discardError(runPromise) {
+  try {
+    return await runPromise();
+  } catch (e2) {
+    return void 0;
+  }
+}
+function getCommandOutput(command) {
+  return discardError(async () => {
+    const result = await exec(command);
+    debug(`Command "${command}" successfully returned "${result.stdout}"`);
+    return result.stdout;
+  });
+}
+async function getArchFromUname() {
+  if (typeof import_os.default["machine"] === "function") {
+    return import_os.default["machine"]();
+  }
+  const arch = await getCommandOutput("uname -m");
+  return arch?.trim();
+}
+function isLibssl1x(libssl) {
+  return libssl.startsWith("1.");
+}

_node_modules/@prisma/get-platform/dist/chunk-FWMN4WME.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_FWMN4WME_exports = {};
+__export(chunk_FWMN4WME_exports, {
+  log: () => log,
+  should: () => should,
+  tags: () => tags,
+  warn: () => warn
+});
+module.exports = __toCommonJS(chunk_FWMN4WME_exports);
+var import_chunk_YVXCXD3A = require("./chunk-YVXCXD3A.js");
+var tags = {
+  warn: (0, import_chunk_YVXCXD3A.yellow)("prisma:warn")
+};
+var should = {
+  warn: () => !process.env.PRISMA_DISABLE_WARNINGS
+};
+function log(...data) {
+  console.log(...data);
+}
+function warn(message, ...optionalParams) {
+  if (should.warn()) {
+    console.warn(`${tags.warn} ${message}`, ...optionalParams);
+  }
+}

_node_modules/@prisma/get-platform/dist/chunk-GGL63BNP.js

@@ -0,0 +1,167 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_GGL63BNP_exports = {};
+__export(chunk_GGL63BNP_exports, {
+  jestConsoleContext: () => jestConsoleContext,
+  jestContext: () => jestContext,
+  jestStdoutContext: () => jestStdoutContext,
+  processExitContext: () => processExitContext
+});
+module.exports = __toCommonJS(chunk_GGL63BNP_exports);
+var import_chunk_3UEKS5W6 = require("./chunk-3UEKS5W6.js");
+var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");
+var import_node_path = __toESM(require("node:path"));
+var import_fs_jetpack = (0, import_chunk_2ESYSVXG.__toESM)((0, import_chunk_3UEKS5W6.require_main)());
+var import_tempy = (0, import_chunk_2ESYSVXG.__toESM)((0, import_chunk_3UEKS5W6.require_tempy)());
+var jestContext = {
+  new: function(ctx = {}) {
+    const c = ctx;
+    beforeEach(() => {
+      const originalCwd = process.cwd();
+      c.mocked = c.mocked ?? {
+        cwd: process.cwd()
+      };
+      c.tmpDir = import_tempy.default.directory();
+      c.fs = import_fs_jetpack.default.cwd(c.tmpDir);
+      c.tree = (startFrom = c.tmpDir, indent = "") => {
+        function* generateDirectoryTree(children2, indent2 = "") {
+          for (const child of children2) {
+            if (child.name === "node_modules" || child.name === ".git") {
+              continue;
+            }
+            if (child.type === "dir") {
+              yield `${indent2}\u2514\u2500\u2500 ${child.name}/`;
+              yield* generateDirectoryTree(child.children, indent2 + "    ");
+            } else if (child.type === "symlink") {
+              yield `${indent2} -> ${child.relativePath}`;
+            } else {
+              yield `${indent2}\u2514\u2500\u2500 ${child.name}`;
+            }
+          }
+        }
+        const children = c.fs.inspectTree(startFrom, { relativePath: true, symlinks: "report" })?.children || [];
+        return `
+${[...generateDirectoryTree(children, indent)].join("\n")}
+`;
+      };
+      c.fixture = (name) => {
+        c.fs.copy(import_node_path.default.join(originalCwd, "src", "__tests__", "fixtures", name), ".", {
+          overwrite: true
+        });
+        c.fs.symlink(import_node_path.default.join(originalCwd, "..", "client"), import_node_path.default.join(c.fs.cwd(), "node_modules", "@prisma", "client"));
+        c.fs.symlink(import_node_path.default.join(originalCwd, "..", "config"), import_node_path.default.join(c.fs.cwd(), "node_modules", "@prisma", "config"));
+      };
+      c.cli = (...input) => {
+        return (0, import_chunk_3UEKS5W6.execaNode)(import_node_path.default.join(originalCwd, "../cli/build/index.js"), input, {
+          cwd: c.fs.cwd(),
+          stdio: "pipe",
+          all: true
+        });
+      };
+      c.printDir = (dir, extensions) => {
+        const content = c.fs.list(dir) ?? [];
+        content.sort((a, b) => a.localeCompare(b));
+        return content.filter((name) => extensions.includes(import_node_path.default.extname(name))).map((name) => `${name}:
+
+${c.fs.read(import_node_path.default.join(dir, name))}`).join("\n\n");
+      };
+      process.chdir(c.tmpDir);
+    });
+    afterEach(() => {
+      process.chdir(c.mocked.cwd);
+    });
+    return factory(ctx);
+  }
+};
+function factory(ctx) {
+  return {
+    add(contextContributor) {
+      const newCtx = contextContributor(ctx);
+      return factory(newCtx);
+    },
+    assemble() {
+      return ctx;
+    }
+  };
+}
+var jestConsoleContext = () => (c) => {
+  const ctx = c;
+  beforeEach(() => {
+    ctx.mocked["console.error"] = jest.spyOn(console, "error").mockImplementation(() => {
+    });
+    ctx.mocked["console.log"] = jest.spyOn(console, "log").mockImplementation(() => {
+    });
+    ctx.mocked["console.info"] = jest.spyOn(console, "info").mockImplementation(() => {
+    });
+    ctx.mocked["console.warn"] = jest.spyOn(console, "warn").mockImplementation(() => {
+    });
+  });
+  afterEach(() => {
+    ctx.mocked["console.error"].mockRestore();
+    ctx.mocked["console.log"].mockRestore();
+    ctx.mocked["console.info"].mockRestore();
+    ctx.mocked["console.warn"].mockRestore();
+  });
+  return ctx;
+};
+var jestStdoutContext = ({ normalizationRules } = { normalizationRules: [] }) => (c) => {
+  const ctx = c;
+  const normalize = (text, rules) => {
+    for (const [pattern, replacement] of rules) {
+      text = text.replace(pattern, replacement);
+    }
+    return text;
+  };
+  beforeEach(() => {
+    ctx.mocked["process.stderr.write"] = jest.spyOn(process.stderr, "write").mockImplementation(() => true);
+    ctx.mocked["process.stdout.write"] = jest.spyOn(process.stdout, "write").mockImplementation(() => true);
+    ctx.normalizedCapturedStdout = () => normalize(ctx.mocked["process.stdout.write"].mock.calls.join(""), normalizationRules);
+    ctx.normalizedCapturedStderr = () => normalize(ctx.mocked["process.stderr.write"].mock.calls.join(""), normalizationRules);
+    ctx.clearCapturedStdout = () => ctx.mocked["process.stdout.write"].mockClear();
+    ctx.clearCapturedStderr = () => ctx.mocked["process.stderr.write"].mockClear();
+  });
+  afterEach(() => {
+    ctx.mocked["process.stderr.write"].mockRestore();
+    ctx.mocked["process.stdout.write"].mockRestore();
+  });
+  return ctx;
+};
+var processExitContext = () => (c) => {
+  const ctx = c;
+  beforeEach(() => {
+    ctx.mocked["process.exit"] = jest.spyOn(process, "exit").mockImplementation((number) => {
+      throw new Error("process.exit: " + number);
+    });
+    ctx.recordedExitCode = () => ctx.mocked["process.exit"].mock.calls[0]?.[0];
+  });
+  afterEach(() => {
+    ctx.mocked["process.exit"].mockRestore();
+  });
+  return ctx;
+};

_node_modules/@prisma/get-platform/dist/chunk-IPLRRT6O.js

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_IPLRRT6O_exports = {};
+__export(chunk_IPLRRT6O_exports, {
+  binaryTargetRegex: () => binaryTargetRegex,
+  binaryTargetRegex_exports: () => binaryTargetRegex_exports,
+  init_binaryTargetRegex: () => init_binaryTargetRegex
+});
+module.exports = __toCommonJS(chunk_IPLRRT6O_exports);
+var import_chunk_7MLUNQIZ = require("./chunk-7MLUNQIZ.js");
+var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");
+function escapeStringRegexp(string) {
+  if (typeof string !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+}
+var init_escape_string_regexp = (0, import_chunk_2ESYSVXG.__esm)({
+  "../../node_modules/.pnpm/escape-string-regexp@5.0.0/node_modules/escape-string-regexp/index.js"() {
+    "use strict";
+  }
+});
+var binaryTargetRegex_exports = {};
+(0, import_chunk_2ESYSVXG.__export)(binaryTargetRegex_exports, {
+  binaryTargetRegex: () => binaryTargetRegex
+});
+var binaryTargetRegex;
+var init_binaryTargetRegex = (0, import_chunk_2ESYSVXG.__esm)({
+  "src/test-utils/binaryTargetRegex.ts"() {
+    init_escape_string_regexp();
+    (0, import_chunk_7MLUNQIZ.init_binaryTargets)();
+    binaryTargetRegex = new RegExp(
+      "(" + [...import_chunk_7MLUNQIZ.binaryTargets].sort((a, b) => b.length - a.length).map((p) => escapeStringRegexp(p)).join("|") + ")",
+      "g"
+    );
+  }
+});

_node_modules/@prisma/get-platform/dist/chunk-M5T7GI2R.js

@@ -0,0 +1,429 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_M5T7GI2R_exports = {};
+__export(chunk_M5T7GI2R_exports, {
+  link: () => link2
+});
+module.exports = __toCommonJS(chunk_M5T7GI2R_exports);
+var import_chunk_YVXCXD3A = require("./chunk-YVXCXD3A.js");
+var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");
+var import_node_process = __toESM(require("node:process"));
+var require_has_flag = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = (flag, argv = process.argv) => {
+      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+      const position = argv.indexOf(prefix + flag);
+      const terminatorPosition = argv.indexOf("--");
+      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+    };
+  }
+});
+var require_supports_color = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports, module2) {
+    "use strict";
+    var os = (0, import_chunk_2ESYSVXG.__require)("os");
+    var tty = (0, import_chunk_2ESYSVXG.__require)("tty");
+    var hasFlag = require_has_flag();
+    var { env } = process;
+    var forceColor;
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      forceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      forceColor = 1;
+    }
+    if ("FORCE_COLOR" in env) {
+      if (env.FORCE_COLOR === "true") {
+        forceColor = 1;
+      } else if (env.FORCE_COLOR === "false") {
+        forceColor = 0;
+      } else {
+        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+      }
+    }
+    function translateLevel(level) {
+      if (level === 0) {
+        return false;
+      }
+      return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+      };
+    }
+    function supportsColor(haveStream, streamIsTTY) {
+      if (forceColor === 0) {
+        return 0;
+      }
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+        return 3;
+      }
+      if (hasFlag("color=256")) {
+        return 2;
+      }
+      if (haveStream && !streamIsTTY && forceColor === void 0) {
+        return 0;
+      }
+      const min = forceColor || 0;
+      if (env.TERM === "dumb") {
+        return min;
+      }
+      if (process.platform === "win32") {
+        const osRelease = os.release().split(".");
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+          return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        }
+        return 1;
+      }
+      if ("CI" in env) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+          return 1;
+        }
+        return min;
+      }
+      if ("TEAMCITY_VERSION" in env) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+      }
+      if (env.COLORTERM === "truecolor") {
+        return 3;
+      }
+      if ("TERM_PROGRAM" in env) {
+        const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env.TERM_PROGRAM) {
+          case "iTerm.app":
+            return version >= 3 ? 3 : 2;
+          case "Apple_Terminal":
+            return 2;
+        }
+      }
+      if (/-256(color)?$/i.test(env.TERM)) {
+        return 2;
+      }
+      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+        return 1;
+      }
+      if ("COLORTERM" in env) {
+        return 1;
+      }
+      return min;
+    }
+    function getSupportLevel(stream) {
+      const level = supportsColor(stream, stream && stream.isTTY);
+      return translateLevel(level);
+    }
+    module2.exports = {
+      supportsColor: getSupportLevel,
+      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+    };
+  }
+});
+var require_supports_hyperlinks = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/supports-hyperlinks@3.2.0/node_modules/supports-hyperlinks/index.js"(exports, module2) {
+    "use strict";
+    var supportsColor = require_supports_color();
+    var hasFlag = require_has_flag();
+    function parseVersion(versionString) {
+      if (/^\d{3,4}$/.test(versionString)) {
+        const m = /(\d{1,2})(\d{2})/.exec(versionString) || [];
+        return {
+          major: 0,
+          minor: parseInt(m[1], 10),
+          patch: parseInt(m[2], 10)
+        };
+      }
+      const versions = (versionString || "").split(".").map((n) => parseInt(n, 10));
+      return {
+        major: versions[0],
+        minor: versions[1],
+        patch: versions[2]
+      };
+    }
+    function supportsHyperlink(stream) {
+      const {
+        CI,
+        FORCE_HYPERLINK,
+        NETLIFY,
+        TEAMCITY_VERSION,
+        TERM_PROGRAM,
+        TERM_PROGRAM_VERSION,
+        VTE_VERSION,
+        TERM
+      } = process.env;
+      if (FORCE_HYPERLINK) {
+        return !(FORCE_HYPERLINK.length > 0 && parseInt(FORCE_HYPERLINK, 10) === 0);
+      }
+      if (hasFlag("no-hyperlink") || hasFlag("no-hyperlinks") || hasFlag("hyperlink=false") || hasFlag("hyperlink=never")) {
+        return false;
+      }
+      if (hasFlag("hyperlink=true") || hasFlag("hyperlink=always")) {
+        return true;
+      }
+      if (NETLIFY) {
+        return true;
+      }
+      if (!supportsColor.supportsColor(stream)) {
+        return false;
+      }
+      if (stream && !stream.isTTY) {
+        return false;
+      }
+      if ("WT_SESSION" in process.env) {
+        return true;
+      }
+      if (process.platform === "win32") {
+        return false;
+      }
+      if (CI) {
+        return false;
+      }
+      if (TEAMCITY_VERSION) {
+        return false;
+      }
+      if (TERM_PROGRAM) {
+        const version = parseVersion(TERM_PROGRAM_VERSION || "");
+        switch (TERM_PROGRAM) {
+          case "iTerm.app":
+            if (version.major === 3) {
+              return version.minor >= 1;
+            }
+            return version.major > 3;
+          case "WezTerm":
+            return version.major >= 20200620;
+          case "vscode":
+            return version.major > 1 || version.major === 1 && version.minor >= 72;
+          case "ghostty":
+            return true;
+        }
+      }
+      if (VTE_VERSION) {
+        if (VTE_VERSION === "0.50.0") {
+          return false;
+        }
+        const version = parseVersion(VTE_VERSION);
+        return version.major > 0 || version.minor >= 50;
+      }
+      switch (TERM) {
+        case "alacritty":
+          return true;
+      }
+      return false;
+    }
+    module2.exports = {
+      supportsHyperlink,
+      stdout: supportsHyperlink(process.stdout),
+      stderr: supportsHyperlink(process.stderr)
+    };
+  }
+});
+var base_exports = {};
+(0, import_chunk_2ESYSVXG.__export)(base_exports, {
+  beep: () => beep,
+  clearScreen: () => clearScreen,
+  clearTerminal: () => clearTerminal,
+  cursorBackward: () => cursorBackward,
+  cursorDown: () => cursorDown,
+  cursorForward: () => cursorForward,
+  cursorGetPosition: () => cursorGetPosition,
+  cursorHide: () => cursorHide,
+  cursorLeft: () => cursorLeft,
+  cursorMove: () => cursorMove,
+  cursorNextLine: () => cursorNextLine,
+  cursorPrevLine: () => cursorPrevLine,
+  cursorRestorePosition: () => cursorRestorePosition,
+  cursorSavePosition: () => cursorSavePosition,
+  cursorShow: () => cursorShow,
+  cursorTo: () => cursorTo,
+  cursorUp: () => cursorUp,
+  enterAlternativeScreen: () => enterAlternativeScreen,
+  eraseDown: () => eraseDown,
+  eraseEndLine: () => eraseEndLine,
+  eraseLine: () => eraseLine,
+  eraseLines: () => eraseLines,
+  eraseScreen: () => eraseScreen,
+  eraseStartLine: () => eraseStartLine,
+  eraseUp: () => eraseUp,
+  exitAlternativeScreen: () => exitAlternativeScreen,
+  iTerm: () => iTerm,
+  image: () => image,
+  link: () => link,
+  scrollDown: () => scrollDown,
+  scrollUp: () => scrollUp
+});
+var isBrowser = globalThis.window?.document !== void 0;
+var isNode = globalThis.process?.versions?.node !== void 0;
+var isBun = globalThis.process?.versions?.bun !== void 0;
+var isDeno = globalThis.Deno?.version?.deno !== void 0;
+var isElectron = globalThis.process?.versions?.electron !== void 0;
+var isJsDom = globalThis.navigator?.userAgent?.includes("jsdom") === true;
+var isWebWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+var isDedicatedWorker = typeof DedicatedWorkerGlobalScope !== "undefined" && globalThis instanceof DedicatedWorkerGlobalScope;
+var isSharedWorker = typeof SharedWorkerGlobalScope !== "undefined" && globalThis instanceof SharedWorkerGlobalScope;
+var isServiceWorker = typeof ServiceWorkerGlobalScope !== "undefined" && globalThis instanceof ServiceWorkerGlobalScope;
+var platform = globalThis.navigator?.userAgentData?.platform;
+var isMacOs = platform === "macOS" || globalThis.navigator?.platform === "MacIntel" || globalThis.navigator?.userAgent?.includes(" Mac ") === true || globalThis.process?.platform === "darwin";
+var isWindows = platform === "Windows" || globalThis.navigator?.platform === "Win32" || globalThis.process?.platform === "win32";
+var isLinux = platform === "Linux" || globalThis.navigator?.platform?.startsWith("Linux") === true || globalThis.navigator?.userAgent?.includes(" Linux ") === true || globalThis.process?.platform === "linux";
+var isIos = platform === "iOS" || globalThis.navigator?.platform === "MacIntel" && globalThis.navigator?.maxTouchPoints > 1 || /iPad|iPhone|iPod/.test(globalThis.navigator?.platform);
+var isAndroid = platform === "Android" || globalThis.navigator?.platform === "Android" || globalThis.navigator?.userAgent?.includes(" Android ") === true || globalThis.process?.platform === "android";
+var ESC = "\x1B[";
+var OSC = "\x1B]";
+var BEL = "\x07";
+var SEP = ";";
+var isTerminalApp = !isBrowser && import_node_process.default.env.TERM_PROGRAM === "Apple_Terminal";
+var isWindows2 = !isBrowser && import_node_process.default.platform === "win32";
+var cwdFunction = isBrowser ? () => {
+  throw new Error("`process.cwd()` only works in Node.js, not the browser.");
+} : import_node_process.default.cwd;
+var cursorTo = (x, y) => {
+  if (typeof x !== "number") {
+    throw new TypeError("The `x` argument is required");
+  }
+  if (typeof y !== "number") {
+    return ESC + (x + 1) + "G";
+  }
+  return ESC + (y + 1) + SEP + (x + 1) + "H";
+};
+var cursorMove = (x, y) => {
+  if (typeof x !== "number") {
+    throw new TypeError("The `x` argument is required");
+  }
+  let returnValue = "";
+  if (x < 0) {
+    returnValue += ESC + -x + "D";
+  } else if (x > 0) {
+    returnValue += ESC + x + "C";
+  }
+  if (y < 0) {
+    returnValue += ESC + -y + "A";
+  } else if (y > 0) {
+    returnValue += ESC + y + "B";
+  }
+  return returnValue;
+};
+var cursorUp = (count = 1) => ESC + count + "A";
+var cursorDown = (count = 1) => ESC + count + "B";
+var cursorForward = (count = 1) => ESC + count + "C";
+var cursorBackward = (count = 1) => ESC + count + "D";
+var cursorLeft = ESC + "G";
+var cursorSavePosition = isTerminalApp ? "\x1B7" : ESC + "s";
+var cursorRestorePosition = isTerminalApp ? "\x1B8" : ESC + "u";
+var cursorGetPosition = ESC + "6n";
+var cursorNextLine = ESC + "E";
+var cursorPrevLine = ESC + "F";
+var cursorHide = ESC + "?25l";
+var cursorShow = ESC + "?25h";
+var eraseLines = (count) => {
+  let clear = "";
+  for (let i = 0; i < count; i++) {
+    clear += eraseLine + (i < count - 1 ? cursorUp() : "");
+  }
+  if (count) {
+    clear += cursorLeft;
+  }
+  return clear;
+};
+var eraseEndLine = ESC + "K";
+var eraseStartLine = ESC + "1K";
+var eraseLine = ESC + "2K";
+var eraseDown = ESC + "J";
+var eraseUp = ESC + "1J";
+var eraseScreen = ESC + "2J";
+var scrollUp = ESC + "S";
+var scrollDown = ESC + "T";
+var clearScreen = "\x1Bc";
+var clearTerminal = isWindows2 ? `${eraseScreen}${ESC}0f` : `${eraseScreen}${ESC}3J${ESC}H`;
+var enterAlternativeScreen = ESC + "?1049h";
+var exitAlternativeScreen = ESC + "?1049l";
+var beep = BEL;
+var link = (text, url) => [
+  OSC,
+  "8",
+  SEP,
+  SEP,
+  url,
+  BEL,
+  text,
+  OSC,
+  "8",
+  SEP,
+  SEP,
+  BEL
+].join("");
+var image = (data, options = {}) => {
+  let returnValue = `${OSC}1337;File=inline=1`;
+  if (options.width) {
+    returnValue += `;width=${options.width}`;
+  }
+  if (options.height) {
+    returnValue += `;height=${options.height}`;
+  }
+  if (options.preserveAspectRatio === false) {
+    returnValue += ";preserveAspectRatio=0";
+  }
+  return returnValue + ":" + Buffer.from(data).toString("base64") + BEL;
+};
+var iTerm = {
+  setCwd: (cwd = cwdFunction()) => `${OSC}50;CurrentDir=${cwd}${BEL}`,
+  annotation(message, options = {}) {
+    let returnValue = `${OSC}1337;`;
+    const hasX = options.x !== void 0;
+    const hasY = options.y !== void 0;
+    if ((hasX || hasY) && !(hasX && hasY && options.length !== void 0)) {
+      throw new Error("`x`, `y` and `length` must be defined when `x` or `y` is defined");
+    }
+    message = message.replaceAll("|", "");
+    returnValue += options.isHidden ? "AddHiddenAnnotation=" : "AddAnnotation=";
+    if (options.length > 0) {
+      returnValue += (hasX ? [message, options.length, options.x, options.y] : [options.length, message]).join("|");
+    } else {
+      returnValue += message;
+    }
+    return returnValue + BEL;
+  }
+};
+var import_supports_hyperlinks = (0, import_chunk_2ESYSVXG.__toESM)(require_supports_hyperlinks(), 1);
+function terminalLink(text, url, { target = "stdout", ...options } = {}) {
+  if (!import_supports_hyperlinks.default[target]) {
+    if (options.fallback === false) {
+      return text;
+    }
+    return typeof options.fallback === "function" ? options.fallback(text, url) : `${text} (\u200B${url}\u200B)`;
+  }
+  return base_exports.link(text, url);
+}
+terminalLink.isSupported = import_supports_hyperlinks.default.stdout;
+terminalLink.stderr = (text, url, options = {}) => terminalLink(text, url, { target: "stderr", ...options });
+terminalLink.stderr.isSupported = import_supports_hyperlinks.default.stderr;
+function link2(url) {
+  return terminalLink(url, url, {
+    fallback: import_chunk_YVXCXD3A.underline
+  });
+}

_node_modules/@prisma/get-platform/dist/chunk-YVXCXD3A.js

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_YVXCXD3A_exports = {};
+__export(chunk_YVXCXD3A_exports, {
+  underline: () => underline,
+  yellow: () => yellow
+});
+module.exports = __toCommonJS(chunk_YVXCXD3A_exports);
+var FORCE_COLOR;
+var NODE_DISABLE_COLORS;
+var NO_COLOR;
+var TERM;
+var isTTY = true;
+if (typeof process !== "undefined") {
+  ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
+  isTTY = process.stdout && process.stdout.isTTY;
+}
+var $ = {
+  enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY)
+};
+function init(x, y) {
+  let rgx = new RegExp(`\\x1b\\[${y}m`, "g");
+  let open = `\x1B[${x}m`, close = `\x1B[${y}m`;
+  return function(txt) {
+    if (!$.enabled || txt == null) return txt;
+    return open + (!!~("" + txt).indexOf(close) ? txt.replace(rgx, close + open) : txt) + close;
+  };
+}
+var reset = init(0, 0);
+var bold = init(1, 22);
+var dim = init(2, 22);
+var italic = init(3, 23);
+var underline = init(4, 24);
+var inverse = init(7, 27);
+var hidden = init(8, 28);
+var strikethrough = init(9, 29);
+var black = init(30, 39);
+var red = init(31, 39);
+var green = init(32, 39);
+var yellow = init(33, 39);
+var blue = init(34, 39);
+var magenta = init(35, 39);
+var cyan = init(36, 39);
+var white = init(37, 39);
+var gray = init(90, 39);
+var grey = init(90, 39);
+var bgBlack = init(40, 49);
+var bgRed = init(41, 49);
+var bgGreen = init(42, 49);
+var bgYellow = init(43, 49);
+var bgBlue = init(44, 49);
+var bgMagenta = init(45, 49);
+var bgCyan = init(46, 49);
+var bgWhite = init(47, 49);

_node_modules/@prisma/get-platform/dist/getPlatform.d.ts

@@ -0,0 +1,105 @@
+/// <reference types="node" />
+import { BinaryTarget } from './binaryTargets';
+declare const supportedLibSSLVersions: readonly ["1.0.x", "1.1.x", "3.0.x"];
+export type Arch = 'x32' | 'x64' | 'arm' | 'arm64' | 's390' | 's390x' | 'mipsel' | 'ia32' | 'mips' | 'ppc' | 'ppc64';
+export type DistroInfo = {
+    /**
+     * The original distro is the Linux distro name detected via its release file.
+     * E.g., on Arch Linux, the original distro is `arch`. On Linux Alpine, the original distro is `alpine`.
+     */
+    originalDistro?: string;
+    /**
+     * The family distro is the Linux distro name that is used to determine Linux families based on the same base distro, and likely using the same package manager.
+     * E.g., both Ubuntu and Debian belong to the `debian` family of distros, and thus rely on the same package manager (`apt`).
+     */
+    familyDistro?: string;
+    /**
+     * The target distro is the Linux distro associated with the Prisma Engines.
+     * E.g., on Arch Linux, Debian, and Ubuntu, the target distro is `debian`. On Linux Alpine, the target distro is `musl`.
+     */
+    targetDistro?: 'rhel' | 'debian' | 'musl' | 'arm' | 'nixos' | 'freebsd11' | 'freebsd12' | 'freebsd13' | 'freebsd14' | 'freebsd15';
+};
+type GetOsResultLinux = {
+    platform: 'linux';
+    arch: Arch;
+    archFromUname: string | undefined;
+    /**
+     * Starting from version 3.0, OpenSSL is basically adopting semver, and will be API and ABI compatible within a major version.
+     */
+    libssl?: (typeof supportedLibSSLVersions)[number];
+} & DistroInfo;
+export type GetOSResult = {
+    platform: Omit<NodeJS.Platform, 'linux'>;
+    arch: Arch;
+    targetDistro?: DistroInfo['targetDistro'];
+    familyDistro?: never;
+    originalDistro?: never;
+    archFromUname?: never;
+    libssl?: never;
+} | GetOsResultLinux;
+/**
+ * For internal use only. This public export will be eventually removed in favor of `getPlatformWithOSResult`.
+ */
+export declare function getos(): Promise<GetOSResult>;
+export declare function parseDistro(osReleaseInput: string): DistroInfo;
+export declare function resolveDistro(): Promise<DistroInfo>;
+/**
+ * Parse the OpenSSL version from the output of the openssl binary, e.g.
+ * "OpenSSL 3.0.2 15 Mar 2022 (Library: OpenSSL 3.0.2 15 Mar 2022)" -> "3.0.x"
+ */
+export declare function parseOpenSSLVersion(input: string): GetOsResultLinux['libssl'] | undefined;
+/**
+ * Parse the OpenSSL version from the output of the libssl.so file, e.g.
+ * "libssl.so.3" -> "3.0.x"
+ */
+export declare function parseLibSSLVersion(input: string): GetOsResultLinux['libssl'];
+type ComputeLibSSLSpecificPathsParams = {
+    arch: Arch;
+    archFromUname: Awaited<ReturnType<typeof getArchFromUname>>;
+    familyDistro: DistroInfo['familyDistro'];
+};
+export declare function computeLibSSLSpecificPaths(args: ComputeLibSSLSpecificPathsParams): string[];
+type GetOpenSSLVersionResult = {
+    libssl: GetOsResultLinux['libssl'];
+    strategy: 'libssl-specific-path' | 'ldconfig' | 'openssl-binary';
+} | {
+    libssl?: never;
+    strategy?: never;
+};
+/**
+ * On Linux, returns the libssl version excluding the patch version, e.g. "1.1.x".
+ * Reading the version from the libssl.so file is more reliable than reading it from the openssl binary.
+ * Older versions of libssl are preferred, e.g. "1.0.x" over "1.1.x", because of Vercel serverless
+ * having different build and runtime environments, with the runtime environment having an old version
+ * of libssl, and the build environment having both that old version and a newer version of libssl installed.
+ * Because of https://github.com/prisma/prisma/issues/17499, we explicitly filter out libssl 0.x.
+ *
+ * This function never throws.
+ */
+export declare function getSSLVersion(libsslSpecificPaths: string[]): Promise<GetOpenSSLVersionResult>;
+/**
+ * Get the binary target for the current platform, e.g. `linux-musl-arm64-openssl-3.0.x` for Linux Alpine on arm64.
+ */
+export declare function getBinaryTargetForCurrentPlatform(): Promise<BinaryTarget>;
+export type PlatformInfo = GetOSResult & {
+    binaryTarget: BinaryTarget;
+};
+/**
+ * Get the binary target and other system information (e.g., the libssl version to look for) for the current platform.
+ */
+export declare function getPlatformInfo(): Promise<PlatformInfo>;
+export declare function getPlatformInfoMemoized(): Promise<PlatformInfo & {
+    memoized: boolean;
+}>;
+/**
+ * This function is only exported for testing purposes.
+ */
+export declare function getBinaryTargetForCurrentPlatformInternal(args: GetOSResult): BinaryTarget;
+/**
+ * Returns the architecture of a system from the output of `uname -m` (whose format is different than `process.arch`).
+ * This function never throws.
+ * TODO: deprecate this function in favor of `os.machine()` once either Node v16.18.0 or v18.9.0 becomes the minimum
+ * supported Node.js version for Prisma.
+ */
+export declare function getArchFromUname(): Promise<string | undefined>;
+export {};

_node_modules/@prisma/get-platform/dist/getPlatform.js

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getPlatform_exports = {};
+__export(getPlatform_exports, {
+  computeLibSSLSpecificPaths: () => import_chunk_7PMGXL6S.computeLibSSLSpecificPaths,
+  getArchFromUname: () => import_chunk_7PMGXL6S.getArchFromUname,
+  getBinaryTargetForCurrentPlatform: () => import_chunk_7PMGXL6S.getBinaryTargetForCurrentPlatform,
+  getBinaryTargetForCurrentPlatformInternal: () => import_chunk_7PMGXL6S.getBinaryTargetForCurrentPlatformInternal,
+  getPlatformInfo: () => import_chunk_7PMGXL6S.getPlatformInfo,
+  getPlatformInfoMemoized: () => import_chunk_7PMGXL6S.getPlatformInfoMemoized,
+  getSSLVersion: () => import_chunk_7PMGXL6S.getSSLVersion,
+  getos: () => import_chunk_7PMGXL6S.getos,
+  parseDistro: () => import_chunk_7PMGXL6S.parseDistro,
+  parseLibSSLVersion: () => import_chunk_7PMGXL6S.parseLibSSLVersion,
+  parseOpenSSLVersion: () => import_chunk_7PMGXL6S.parseOpenSSLVersion,
+  resolveDistro: () => import_chunk_7PMGXL6S.resolveDistro
+});
+module.exports = __toCommonJS(getPlatform_exports);
+var import_chunk_7PMGXL6S = require("./chunk-7PMGXL6S.js");
+var import_chunk_FWMN4WME = require("./chunk-FWMN4WME.js");
+var import_chunk_YVXCXD3A = require("./chunk-YVXCXD3A.js");
+var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");

_node_modules/@prisma/get-platform/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { type BinaryTarget, binaryTargets } from './binaryTargets';
+export type { PlatformInfo } from './getPlatform';
+export { getBinaryTargetForCurrentPlatform, getos, getPlatformInfo } from './getPlatform';
+export { link } from './link';
+export * from './test-utils';

_node_modules/@prisma/get-platform/dist/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  binaryTargets: () => import_chunk_7MLUNQIZ.binaryTargets,
+  getBinaryTargetForCurrentPlatform: () => import_chunk_7PMGXL6S.getBinaryTargetForCurrentPlatform,
+  getPlatformInfo: () => import_chunk_7PMGXL6S.getPlatformInfo,
+  getos: () => import_chunk_7PMGXL6S.getos,
+  jestConsoleContext: () => import_chunk_GGL63BNP.jestConsoleContext,
+  jestContext: () => import_chunk_GGL63BNP.jestContext,
+  jestStdoutContext: () => import_chunk_GGL63BNP.jestStdoutContext,
+  link: () => import_chunk_M5T7GI2R.link,
+  processExitContext: () => import_chunk_GGL63BNP.processExitContext
+});
+module.exports = __toCommonJS(index_exports);
+var import_chunk_7PMGXL6S = require("./chunk-7PMGXL6S.js");
+var import_chunk_M5T7GI2R = require("./chunk-M5T7GI2R.js");
+var import_chunk_FWMN4WME = require("./chunk-FWMN4WME.js");
+var import_chunk_YVXCXD3A = require("./chunk-YVXCXD3A.js");
+var import_chunk_7MLUNQIZ = require("./chunk-7MLUNQIZ.js");
+var import_chunk_6HZWON4S = require("./chunk-6HZWON4S.js");
+var import_chunk_GGL63BNP = require("./chunk-GGL63BNP.js");
+var import_chunk_3UEKS5W6 = require("./chunk-3UEKS5W6.js");
+var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");
+(0, import_chunk_7MLUNQIZ.init_binaryTargets)();

_node_modules/@prisma/get-platform/dist/link.d.ts

@@ -0,0 +1 @@
+export declare function link(url: any): string;

_node_modules/@prisma/get-platform/dist/link.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var link_exports = {};
+__export(link_exports, {
+  link: () => import_chunk_M5T7GI2R.link
+});
+module.exports = __toCommonJS(link_exports);
+var import_chunk_M5T7GI2R = require("./chunk-M5T7GI2R.js");
+var import_chunk_YVXCXD3A = require("./chunk-YVXCXD3A.js");
+var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");

_node_modules/@prisma/get-platform/dist/logger.d.ts

@@ -0,0 +1,8 @@
+export declare const tags: {
+    warn: string;
+};
+export declare const should: {
+    warn: () => boolean;
+};
+export declare function log(...data: any[]): void;
+export declare function warn(message: any, ...optionalParams: any[]): void;

_node_modules/@prisma/get-platform/dist/logger.js

@@ -0,0 +1,29 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logger_exports = {};
+__export(logger_exports, {
+  log: () => import_chunk_FWMN4WME.log,
+  should: () => import_chunk_FWMN4WME.should,
+  tags: () => import_chunk_FWMN4WME.tags,
+  warn: () => import_chunk_FWMN4WME.warn
+});
+module.exports = __toCommonJS(logger_exports);
+var import_chunk_FWMN4WME = require("./chunk-FWMN4WME.js");
+var import_chunk_YVXCXD3A = require("./chunk-YVXCXD3A.js");
+var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");

_node_modules/@prisma/get-platform/dist/test-utils/binaryTargetRegex.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This regex matches all supported binary target names in a given string.
+ *
+ * Platform names are sorted by their lengths in descending order to ensure that
+ * the longest substring is always matched (e.g., "darwin-arm64" is matched as a
+ * whole instead of "darwin" and "arm" separately)
+ */
+export declare const binaryTargetRegex: RegExp;

_node_modules/@prisma/get-platform/dist/test-utils/binaryTargetRegex.js

@@ -0,0 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var binaryTargetRegex_exports = {};
+__export(binaryTargetRegex_exports, {
+  binaryTargetRegex: () => import_chunk_IPLRRT6O.binaryTargetRegex
+});
+module.exports = __toCommonJS(binaryTargetRegex_exports);
+var import_chunk_IPLRRT6O = require("../chunk-IPLRRT6O.js");
+var import_chunk_7MLUNQIZ = require("../chunk-7MLUNQIZ.js");
+var import_chunk_2ESYSVXG = require("../chunk-2ESYSVXG.js");
+(0, import_chunk_IPLRRT6O.init_binaryTargetRegex)();

_node_modules/@prisma/get-platform/dist/test-utils/index.d.ts

@@ -0,0 +1 @@
+export { type BaseContext, jestConsoleContext, jestContext, jestStdoutContext, type ProcessContextSettings, processExitContext, } from './jestContext';

_node_modules/@prisma/get-platform/dist/test-utils/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var test_utils_exports = {};
+__export(test_utils_exports, {
+  jestConsoleContext: () => import_chunk_GGL63BNP.jestConsoleContext,
+  jestContext: () => import_chunk_GGL63BNP.jestContext,
+  jestStdoutContext: () => import_chunk_GGL63BNP.jestStdoutContext,
+  processExitContext: () => import_chunk_GGL63BNP.processExitContext
+});
+module.exports = __toCommonJS(test_utils_exports);
+var import_chunk_6HZWON4S = require("../chunk-6HZWON4S.js");
+var import_chunk_GGL63BNP = require("../chunk-GGL63BNP.js");
+var import_chunk_3UEKS5W6 = require("../chunk-3UEKS5W6.js");
+var import_chunk_2ESYSVXG = require("../chunk-2ESYSVXG.js");

_node_modules/@prisma/get-platform/dist/test-utils/jestContext.d.ts

@@ -0,0 +1,122 @@
+/// <reference types="jest" />
+import { type ExecaChildProcess } from 'execa';
+import type { FSJetpack } from 'fs-jetpack/types';
+/**
+ * Base test context.
+ */
+export type BaseContext = {
+    tmpDir: string;
+    fs: FSJetpack;
+    mocked: {
+        cwd: string;
+    };
+    /**
+     * Set up the temporary directory based on the contents of some fixture.
+     */
+    fixture: (name: string) => void;
+    /**
+     * Spawn the Prisma cli using the temporary directory as the CWD.
+     *
+     * @remarks
+     *
+     * For this to work the source must be built
+     */
+    cli: (...input: string[]) => ExecaChildProcess<string>;
+    printDir(dir: string, extensions: string[]): void;
+    /**
+     * JavaScript-friendly implementation of the `tree` command. It skips the `node_modules` directory.
+     * @param itemPath The path to start the tree from, defaults to the root of the temporary directory
+     * @param indent How much to indent each level of the tree, defaults to ''
+     * @returns String representation of the directory tree
+     */
+    tree: (itemPath?: string, indent?: string) => void;
+};
+/**
+ * Create test context to use in tests. Provides the following:
+ *
+ * - A temporary directory
+ * - an fs-jetpack instance bound to the temporary directory
+ * - Mocked process.cwd via Node process.chdir
+ * - Fixture loader for bootstrapping the temporary directory with content
+ */
+export declare const jestContext: {
+    new: (ctx?: BaseContext) => {
+        add<NewContext>(contextContributor: ContextContributor<BaseContext, NewContext>): {
+            add<NewContext_1>(contextContributor: ContextContributor<BaseContext & NewContext, NewContext_1>): {
+                add<NewContext_2>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1, NewContext_2>): {
+                    add<NewContext_3>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2, NewContext_3>): {
+                        add<NewContext_4>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3, NewContext_4>): {
+                            add<NewContext_5>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4, NewContext_5>): {
+                                add<NewContext_6>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5, NewContext_6>): {
+                                    add<NewContext_7>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6, NewContext_7>): {
+                                        add<NewContext_8>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7, NewContext_8>): {
+                                            add<NewContext_9>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7 & NewContext_8, NewContext_9>): {
+                                                add<NewContext_10>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7 & NewContext_8 & NewContext_9, NewContext_10>): any;
+                                                assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7 & NewContext_8 & NewContext_9;
+                                            };
+                                            assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7 & NewContext_8;
+                                        };
+                                        assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7;
+                                    };
+                                    assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6;
+                                };
+                                assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5;
+                            };
+                            assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4;
+                        };
+                        assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3;
+                    };
+                    assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2;
+                };
+                assemble(): BaseContext & NewContext & NewContext_1;
+            };
+            assemble(): BaseContext & NewContext;
+        };
+        assemble(): BaseContext;
+    };
+};
+/**
+ * A function that provides additional test context.
+ */
+type ContextContributor<Context, NewContext> = (ctx: Context) => Context & NewContext;
+/**
+ * Test context contributor. Mocks console.error with a Jest spy before each test.
+ */
+type ConsoleContext = {
+    mocked: {
+        'console.error': jest.SpyInstance;
+        'console.log': jest.SpyInstance;
+        'console.info': jest.SpyInstance;
+        'console.warn': jest.SpyInstance;
+    };
+};
+export declare const jestConsoleContext: <Ctx extends BaseContext>() => (c: Ctx) => Ctx & ConsoleContext;
+/**
+ * Test context contributor. Mocks process.std(out|err).write with a Jest spy before each test.
+ */
+type ProcessContext = {
+    mocked: {
+        'process.stderr.write': jest.SpyInstance;
+        'process.stdout.write': jest.SpyInstance;
+    };
+    normalizedCapturedStdout: () => string;
+    normalizedCapturedStderr: () => string;
+    clearCapturedStdout: () => void;
+    clearCapturedStderr: () => void;
+};
+type NormalizationRule = [RegExp | string, string];
+export type ProcessContextSettings = {
+    normalizationRules: NormalizationRule[];
+};
+export declare const jestStdoutContext: <Ctx extends BaseContext>({ normalizationRules }?: ProcessContextSettings) => (c: Ctx) => Ctx & ProcessContext;
+/**
+ * Test context contributor. Mocks process.exit with a spay and records the exit code.
+ */
+type ProcessExitContext = {
+    mocked: {
+        'process.exit': jest.SpyInstance;
+    };
+    recordedExitCode: () => number;
+};
+export declare const processExitContext: <C extends BaseContext>() => (c: C) => C & ProcessExitContext;
+export {};

_node_modules/@prisma/get-platform/dist/test-utils/jestContext.js

@@ -0,0 +1,29 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jestContext_exports = {};
+__export(jestContext_exports, {
+  jestConsoleContext: () => import_chunk_GGL63BNP.jestConsoleContext,
+  jestContext: () => import_chunk_GGL63BNP.jestContext,
+  jestStdoutContext: () => import_chunk_GGL63BNP.jestStdoutContext,
+  processExitContext: () => import_chunk_GGL63BNP.processExitContext
+});
+module.exports = __toCommonJS(jestContext_exports);
+var import_chunk_GGL63BNP = require("../chunk-GGL63BNP.js");
+var import_chunk_3UEKS5W6 = require("../chunk-3UEKS5W6.js");
+var import_chunk_2ESYSVXG = require("../chunk-2ESYSVXG.js");

_node_modules/@prisma/get-platform/dist/test-utils/jestSnapshotSerializer.js

@@ -0,0 +1,151 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jestSnapshotSerializer_exports = {};
+__export(jestSnapshotSerializer_exports, {
+  default: () => jestSnapshotSerializer_default
+});
+module.exports = __toCommonJS(jestSnapshotSerializer_exports);
+var import_chunk_IPLRRT6O = require("../chunk-IPLRRT6O.js");
+var import_chunk_7MLUNQIZ = require("../chunk-7MLUNQIZ.js");
+var import_chunk_2ESYSVXG = require("../chunk-2ESYSVXG.js");
+var require_jestSnapshotSerializer = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "src/test-utils/jestSnapshotSerializer.js"(exports, module2) {
+    var path = (0, import_chunk_2ESYSVXG.__require)("node:path");
+    var { stripVTControlCharacters } = (0, import_chunk_2ESYSVXG.__require)("node:util");
+    var { binaryTargetRegex } = ((0, import_chunk_IPLRRT6O.init_binaryTargetRegex)(), (0, import_chunk_2ESYSVXG.__toCommonJS)(import_chunk_IPLRRT6O.binaryTargetRegex_exports));
+    var pipe = (...fns) => (x) => fns.reduce((v, f) => f(v), x);
+    function normalizePrismaPaths(str) {
+      return str.replace(/prisma\\([\w-]+)\.prisma/g, "prisma/$1.prisma").replace(/prisma\\seed\.ts/g, "prisma/seed.ts").replace(/custom-folder\\seed\.js/g, "custom-folder/seed.js");
+    }
+    function normalizeLogs(str) {
+      return str.replace(
+        /Started query engine http server on http:\/\/127\.0\.0\.1:\d{1,5}/g,
+        "Started query engine http server on http://127.0.0.1:00000"
+      ).replace(/Starting a postgresql pool with \d+ connections./g, "Starting a postgresql pool with XX connections.");
+    }
+    function normalizeTmpDir(str) {
+      const tempDirRegexes = [
+        // Linux
+        /\/tmp\/([a-z0-9]+)/g,
+        // macOS
+        /\/private\/var\/folders\/[^/]+\/[^/]+\/T\/[a-z0-9]+/g
+      ];
+      if (process.env.TEMP) {
+        const escapedPath = process.env.TEMP.replaceAll("\\", "\\\\");
+        tempDirRegexes.push(new RegExp(`${escapedPath}\\\\[a-z0-9]+`, "g"));
+      }
+      for (const regex of tempDirRegexes) {
+        str = str.replace(regex, "/tmp/dir");
+      }
+      return str;
+    }
+    function trimErrorPaths(str) {
+      const parentDir = path.dirname(path.dirname(path.dirname(__dirname)));
+      return str.replaceAll(parentDir, "");
+    }
+    function normalizeToUnixPaths(str) {
+      return str.replaceAll(path.sep, "/");
+    }
+    function normalizeGitHubLinks(str) {
+      return str.replace(/https:\/\/github.com\/prisma\/prisma(-client-js)?\/issues\/new\S+/, "TEST_GITHUB_LINK");
+    }
+    function normalizeTsClientStackTrace(str) {
+      return str.replace(/([/\\]client[/\\]src[/\\]__tests__[/\\].*test\.ts)(:\d*:\d*)/, "$1:0:0").replace(/([/\\]client[/\\]tests[/\\]functional[/\\].*\.ts)(:\d*:\d*)/, "$1:0:0");
+    }
+    function removePlatforms(str) {
+      return str.replace(binaryTargetRegex, "TEST_PLATFORM");
+    }
+    function normalizeBinaryFilePath(str) {
+      return str.replace(/\.exe(\s+)?(\W.*)/g, "$1$2").replace(/\.exe$/g, "");
+    }
+    function normalizeMigrateTimestamps(str) {
+      return str.replace(/(?<!\d)\d{14}(?!\d)/g, "20201231000000");
+    }
+    function normalizeDbUrl(str) {
+      return str.replace(/(localhost|postgres|mysql|mssql|mongodb_migrate|cockroachdb):(\d+)/g, "localhost:$2");
+    }
+    function normalizeRustError(str) {
+      return str.replace(/\/rustc\/(.+)\//g, "/rustc/hash/").replace(/(\[.*)(:\d*:\d*)(\])/g, "[/some/rust/path:0:0$3");
+    }
+    function normalizeRustCodeLocation(str) {
+      return str.replace(/(\w+\.rs):(\d+):(\d+)/g, "$1:0:0");
+    }
+    function normalizeArtificialPanic(str) {
+      return str.replace(/(Command failed with exit code 101:) (.+) /g, "$1 prisma-engines-path ");
+    }
+    function normalizeTime(str) {
+      return str.replace(/ \d+ms/g, " XXXms").replace(/ \d+(\.\d+)?s/g, " XXXms");
+    }
+    function prepareSchemaForSnapshot(str) {
+      if (!str.includes("tmp/prisma-tests/integration-test")) return str;
+      const urlRegex = /url\s*=\s*.+/;
+      const outputRegex = /output\s*=\s*.+/;
+      return str.split("\n").map((line) => {
+        const urlMatch = urlRegex.exec(line);
+        if (urlMatch) {
+          return `${line.slice(0, urlMatch.index)}url = "***"`;
+        }
+        const outputMatch = outputRegex.exec(line);
+        if (outputMatch) {
+          return `${line.slice(0, outputMatch.index)}output = "***"`;
+        }
+        return line;
+      }).join("\n");
+    }
+    function wrapWithQuotes(str) {
+      return `"${str}"`;
+    }
+    module2.exports = {
+      // Expected by Jest
+      test(value) {
+        return typeof value === "string" || value instanceof Error;
+      },
+      serialize(value) {
+        const message = typeof value === "string" ? value : value instanceof Error ? value.message : "";
+        return pipe(
+          stripVTControlCharacters,
+          // integration-tests pkg
+          prepareSchemaForSnapshot,
+          // Generic
+          normalizeTmpDir,
+          normalizeTime,
+          // From Client package
+          normalizeGitHubLinks,
+          removePlatforms,
+          normalizeBinaryFilePath,
+          normalizeTsClientStackTrace,
+          trimErrorPaths,
+          normalizePrismaPaths,
+          normalizeLogs,
+          // remove windows \\
+          normalizeToUnixPaths,
+          // From Migrate/CLI package
+          normalizeDbUrl,
+          normalizeRustError,
+          normalizeRustCodeLocation,
+          normalizeMigrateTimestamps,
+          // artificial panic
+          normalizeArtificialPanic,
+          wrapWithQuotes
+        )(message);
+      }
+    };
+  }
+});
+var jestSnapshotSerializer_default = require_jestSnapshotSerializer();

_node_modules/@prisma/get-platform/dist/test-utils/vitestContext.d.ts

@@ -0,0 +1,123 @@
+import { type ExecaChildProcess } from 'execa';
+import type { FSJetpack } from 'fs-jetpack/types';
+import { type MockInstance } from 'vitest';
+/**
+ * Base test context.
+ */
+export type BaseContext = {
+    tmpDir: string;
+    fs: FSJetpack;
+    mocked: {
+        cwd: string;
+    };
+    /**
+     * Set up the temporary directory based on the contents of some fixture.
+     */
+    fixture: (name: string) => void;
+    /**
+     * Spawn the Prisma cli using the temporary directory as the CWD.
+     *
+     * @remarks
+     *
+     * For this to work the source must be built
+     */
+    cli: (...input: string[]) => ExecaChildProcess<string>;
+    printDir(dir: string, extensions: string[]): void;
+    /**
+     * JavaScript-friendly implementation of the `tree` command. It skips the `node_modules` directory.
+     * @param itemPath The path to start the tree from, defaults to the root of the temporary directory
+     * @param indent How much to indent each level of the tree, defaults to ''
+     * @returns String representation of the directory tree
+     */
+    tree: (itemPath?: string, indent?: string) => void;
+};
+/**
+ * Create test context to use in tests. Provides the following:
+ *
+ * - A temporary directory
+ * - an fs-jetpack instance bound to the temporary directory
+ * - Mocked process.cwd via Node process.chdir
+ * - Fixture loader for bootstrapping the temporary directory with content
+ */
+export declare const vitestContext: {
+    new: (ctx?: BaseContext) => {
+        add<NewContext>(contextContributor: ContextContributor<BaseContext, NewContext>): {
+            add<NewContext_1>(contextContributor: ContextContributor<BaseContext & NewContext, NewContext_1>): {
+                add<NewContext_2>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1, NewContext_2>): {
+                    add<NewContext_3>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2, NewContext_3>): {
+                        add<NewContext_4>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3, NewContext_4>): {
+                            add<NewContext_5>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4, NewContext_5>): {
+                                add<NewContext_6>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5, NewContext_6>): {
+                                    add<NewContext_7>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6, NewContext_7>): {
+                                        add<NewContext_8>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7, NewContext_8>): {
+                                            add<NewContext_9>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7 & NewContext_8, NewContext_9>): {
+                                                add<NewContext_10>(contextContributor: ContextContributor<BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7 & NewContext_8 & NewContext_9, NewContext_10>): any;
+                                                assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7 & NewContext_8 & NewContext_9;
+                                            };
+                                            assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7 & NewContext_8;
+                                        };
+                                        assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6 & NewContext_7;
+                                    };
+                                    assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5 & NewContext_6;
+                                };
+                                assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4 & NewContext_5;
+                            };
+                            assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3 & NewContext_4;
+                        };
+                        assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2 & NewContext_3;
+                    };
+                    assemble(): BaseContext & NewContext & NewContext_1 & NewContext_2;
+                };
+                assemble(): BaseContext & NewContext & NewContext_1;
+            };
+            assemble(): BaseContext & NewContext;
+        };
+        assemble(): BaseContext;
+    };
+};
+/**
+ * A function that provides additional test context.
+ */
+type ContextContributor<Context, NewContext> = (ctx: Context) => Context & NewContext;
+/**
+ * Test context contributor. Mocks console.error with a Vitest spy before each test.
+ */
+type ConsoleContext = {
+    mocked: {
+        'console.error': MockInstance<typeof console.error>;
+        'console.log': MockInstance<typeof console.log>;
+        'console.info': MockInstance<typeof console.info>;
+        'console.warn': MockInstance<typeof console.warn>;
+    };
+};
+export declare const vitestConsoleContext: <Ctx extends BaseContext>() => (c: Ctx) => Ctx & ConsoleContext;
+/**
+ * Test context contributor. Mocks process.std(out|err).write with a Vitest spy before each test.
+ */
+type ProcessContext = {
+    mocked: {
+        'process.stderr.write': MockInstance<typeof process.stderr.write>;
+        'process.stdout.write': MockInstance<typeof process.stdout.write>;
+    };
+    normalizedCapturedStdout: () => string;
+    normalizedCapturedStderr: () => string;
+    clearCapturedStdout: () => void;
+    clearCapturedStderr: () => void;
+};
+type NormalizationRule = [RegExp | string, string];
+export type ProcessContextSettings = {
+    normalizationRules: NormalizationRule[];
+};
+export declare const vitestStdoutContext: <Ctx extends BaseContext>({ normalizationRules }?: ProcessContextSettings) => (c: Ctx) => Ctx & ProcessContext;
+/**
+ * Test context contributor. Mocks process.exit with a spy and records the exit code.
+ */
+type ProcessExitContext = {
+    mocked: {
+        'process.exit': MockInstance<typeof process.exit>;
+    };
+    recordedExitCode: () => number;
+};
+export declare const vitestProcessExitContext: <C extends BaseContext>() => (c: C) => C & ProcessExitContext;
+export declare const processExitContext: <C extends BaseContext>() => (c: C) => C & ProcessExitContext;
+export {};