@ohos-ports/prisma-internals 7.10.0-beta.0

package/dist/chunk-JTKAT4KZ.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 chunk_JTKAT4KZ_exports = {};
+__export(chunk_JTKAT4KZ_exports, {
+  isPromiseLike: () => isPromiseLike
+});
+module.exports = __toCommonJS(chunk_JTKAT4KZ_exports);
+function isPromiseLike(value) {
+  return value != null && typeof value["then"] === "function";
+}

package/dist/chunk-K2EOOA2X.js

@@ -0,0 +1,91 @@
+"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_K2EOOA2X_exports = {};
+__export(chunk_K2EOOA2X_exports, {
+  createDirIfNotExists: () => createDirIfNotExists,
+  fs_utils_exports: () => fs_utils_exports,
+  getFilesInDir: () => getFilesInDir,
+  getNestedFoldersInDir: () => getNestedFoldersInDir,
+  getTopLevelFoldersInDir: () => getTopLevelFoldersInDir,
+  removeEmptyDirs: () => removeEmptyDirs,
+  writeFile: () => writeFile
+});
+module.exports = __toCommonJS(chunk_K2EOOA2X_exports);
+var import_chunk_J77ZIDXB = require("./chunk-J77ZIDXB.js");
+var import_chunk_JPZYSRK3 = require("./chunk-JPZYSRK3.js");
+var import_chunk_4VNS5WPM = require("./chunk-4VNS5WPM.js");
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var fs_utils_exports = {};
+(0, import_chunk_4VNS5WPM.__export)(fs_utils_exports, {
+  createDirIfNotExists: () => createDirIfNotExists,
+  getFilesInDir: () => getFilesInDir,
+  getNestedFoldersInDir: () => getNestedFoldersInDir,
+  getTopLevelFoldersInDir: () => getTopLevelFoldersInDir,
+  removeEmptyDirs: () => removeEmptyDirs,
+  writeFile: () => writeFile
+});
+var import_globby = (0, import_chunk_4VNS5WPM.__toESM)((0, import_chunk_JPZYSRK3.require_globby)());
+function createDirIfNotExists(dir) {
+  return import_promises.default.mkdir(dir, { recursive: true });
+}
+function writeFile({ path: path2, content }) {
+  return import_promises.default.writeFile(path2, content, { encoding: "utf-8" });
+}
+async function getTopLevelFoldersInDir(dir) {
+  const rawFolders = await import_promises.default.readdir(dir, { withFileTypes: true });
+  return rawFolders.filter((fileOrFolder) => fileOrFolder.isDirectory()).map((folder) => (0, import_chunk_J77ZIDXB.pathToPosix)(import_path.default.join(dir, folder.name)));
+}
+function getNestedFoldersInDir(dir) {
+  const normalizedDir = (0, import_chunk_J77ZIDXB.pathToPosix)(import_path.default.join(dir, "**"));
+  return (0, import_globby.default)(normalizedDir, { onlyFiles: false, onlyDirectories: true });
+}
+function getFilesInDir(dir, pattern = "**") {
+  const normalizedDir = (0, import_chunk_J77ZIDXB.pathToPosix)(import_path.default.join(dir, pattern));
+  return (0, import_globby.default)(normalizedDir, { onlyFiles: true, onlyDirectories: false });
+}
+async function removeEmptyDirs(dir) {
+  try {
+    const fileStats = await import_promises.default.lstat(dir);
+    if (!fileStats.isDirectory()) {
+      return;
+    }
+  } catch (e) {
+    return;
+  }
+  const filenames = await import_promises.default.readdir(dir);
+  if (filenames.length > 0) {
+    const recursionPromises = filenames.map((filename) => removeEmptyDirs(import_path.default.join(dir, filename)));
+    await Promise.all(recursionPromises);
+  }
+  const filenamesAfterRec = await import_promises.default.readdir(dir);
+  if (filenamesAfterRec.length === 0) {
+    await import_promises.default.rmdir(dir);
+  }
+}

package/dist/chunk-KDP6C3CB.js

@@ -0,0 +1,56 @@
+"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_KDP6C3CB_exports = {};
+__export(chunk_KDP6C3CB_exports, {
+  require_indent_string: () => require_indent_string
+});
+module.exports = __toCommonJS(chunk_KDP6C3CB_exports);
+var import_chunk_4VNS5WPM = require("./chunk-4VNS5WPM.js");
+var require_indent_string = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/indent-string@4.0.0/node_modules/indent-string/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = (string, count = 1, options) => {
+      options = {
+        indent: " ",
+        includeEmptyLines: false,
+        ...options
+      };
+      if (typeof string !== "string") {
+        throw new TypeError(
+          `Expected \`input\` to be a \`string\`, got \`${typeof string}\``
+        );
+      }
+      if (typeof count !== "number") {
+        throw new TypeError(
+          `Expected \`count\` to be a \`number\`, got \`${typeof count}\``
+        );
+      }
+      if (typeof options.indent !== "string") {
+        throw new TypeError(
+          `Expected \`options.indent\` to be a \`string\`, got \`${typeof options.indent}\``
+        );
+      }
+      if (count === 0) {
+        return string;
+      }
+      const regex = options.includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
+      return string.replace(regex, options.indent.repeat(count));
+    };
+  }
+});

package/dist/chunk-L3LDE52J.js

@@ -0,0 +1,51 @@
+"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_L3LDE52J_exports = {};
+__export(chunk_L3LDE52J_exports, {
+  prismaSchemaWasm: () => import_prisma_schema_wasm.default,
+  prismaSchemaWasmVersion: () => prismaSchemaWasmVersion,
+  schemaEngineWasmVersion: () => schemaEngineWasmVersion,
+  wasm_exports: () => wasm_exports
+});
+module.exports = __toCommonJS(chunk_L3LDE52J_exports);
+var import_chunk_I2CBQZJY = require("./chunk-I2CBQZJY.js");
+var import_chunk_WXRVYSYN = require("./chunk-WXRVYSYN.js");
+var import_chunk_4VNS5WPM = require("./chunk-4VNS5WPM.js");
+var import_prisma_schema_wasm = __toESM(require("@prisma/prisma-schema-wasm"));
+var wasm_exports = {};
+(0, import_chunk_4VNS5WPM.__export)(wasm_exports, {
+  prismaSchemaWasm: () => import_prisma_schema_wasm.default,
+  prismaSchemaWasmVersion: () => prismaSchemaWasmVersion,
+  schemaEngineWasmVersion: () => schemaEngineWasmVersion
+});
+var globalWithPanicRegistry = globalThis;
+globalWithPanicRegistry.PRISMA_WASM_PANIC_REGISTRY = new import_chunk_WXRVYSYN.WasmPanicRegistry();
+var { dependencies } = (0, import_chunk_I2CBQZJY.require_package)();
+var prismaSchemaWasmVersion = dependencies["@prisma/prisma-schema-wasm"];
+var schemaEngineWasmVersion = dependencies["@prisma/schema-engine-wasm"];

package/dist/chunk-L6V54WGO.js

@@ -0,0 +1,39 @@
+"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_L6V54WGO_exports = {};
+__export(chunk_L6V54WGO_exports, {
+  getEngineVersion: () => getEngineVersion,
+  safeGetEngineVersion: () => safeGetEngineVersion
+});
+module.exports = __toCommonJS(chunk_L6V54WGO_exports);
+var import_chunk_JOIHHXR6 = require("./chunk-JOIHHXR6.js");
+var import_chunk_5PJQQKQI = require("./chunk-5PJQQKQI.js");
+var import_chunk_5DBOS77Y = require("./chunk-5DBOS77Y.js");
+var import_fetch_engine = require("@prisma/fetch-engine");
+async function getEngineVersion(enginePath, binaryName) {
+  enginePath = await (0, import_chunk_5PJQQKQI.resolveBinary)(binaryName ?? import_fetch_engine.BinaryType.SchemaEngineBinary, enginePath);
+  const { stdout } = await (0, import_chunk_JOIHHXR6.execa)(enginePath, ["--version"]);
+  return stdout;
+}
+function safeGetEngineVersion(enginePath, binaryName) {
+  return (0, import_chunk_5DBOS77Y.tryCatch2)(
+    () => getEngineVersion(enginePath, binaryName),
+    (error) => error
+  );
+}

package/dist/chunk-LMVSIVKQ.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_LMVSIVKQ_exports = {};
+__export(chunk_LMVSIVKQ_exports, {
+  ErrorArea: () => ErrorArea,
+  RustPanic: () => RustPanic,
+  getWasmError: () => getWasmError,
+  isRustPanic: () => isRustPanic,
+  isWasmPanic: () => isWasmPanic
+});
+module.exports = __toCommonJS(chunk_LMVSIVKQ_exports);
+var RustPanic = class extends Error {
+  __typename = "RustPanic";
+  request;
+  rustStack;
+  area;
+  introspectionUrl;
+  constructor(message, rustStack, request, area, introspectionUrl) {
+    super(message);
+    this.name = "RustPanic";
+    this.rustStack = rustStack;
+    this.request = request;
+    this.area = area;
+    this.introspectionUrl = introspectionUrl;
+  }
+};
+function isRustPanic(e) {
+  return e.__typename === "RustPanic";
+}
+var ErrorArea = /* @__PURE__ */ ((ErrorArea2) => {
+  ErrorArea2["LIFT_CLI"] = "LIFT_CLI";
+  ErrorArea2["PHOTON_STUDIO"] = "PHOTON_STUDIO";
+  ErrorArea2["INTROSPECTION_CLI"] = "INTROSPECTION_CLI";
+  ErrorArea2["FMT_CLI"] = "FMT_CLI";
+  ErrorArea2["QUERY_ENGINE_BINARY_CLI"] = "QUERY_ENGINE_BINARY_CLI";
+  ErrorArea2["QUERY_ENGINE_LIBRARY_CLI"] = "QUERY_ENGINE_LIBRARY_CLI";
+  return ErrorArea2;
+})(ErrorArea || {});
+function isWasmPanic(error) {
+  return error.name === "RuntimeError";
+}
+function getWasmError(error) {
+  const message = globalThis.PRISMA_WASM_PANIC_REGISTRY.get();
+  const stack = [message, ...(error.stack || "NO_BACKTRACE").split("\n").slice(1)].join("\n");
+  return { message, stack };
+}

package/dist/chunk-LPNBWFQ3.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 chunk_LPNBWFQ3_exports = {};
+__export(chunk_LPNBWFQ3_exports, {
+  PRISMA_POSTGRES_PROTOCOL: () => PRISMA_POSTGRES_PROTOCOL,
+  PRISMA_POSTGRES_PROVIDER: () => PRISMA_POSTGRES_PROVIDER,
+  isPrismaPostgres: () => isPrismaPostgres,
+  isPrismaPostgresDev: () => isPrismaPostgresDev
+});
+module.exports = __toCommonJS(chunk_LPNBWFQ3_exports);
+var PRISMA_POSTGRES_PROVIDER = "prisma+postgres";
+var PRISMA_POSTGRES_PROTOCOL = `${PRISMA_POSTGRES_PROVIDER}:`;
+function isPrismaPostgres(connectionString) {
+  return connectionString?.toString().startsWith(`${PRISMA_POSTGRES_PROTOCOL}//`) ?? false;
+}
+function isPrismaPostgresDev(connectionString) {
+  if (!isPrismaPostgres(connectionString)) {
+    return false;
+  }
+  const { host } = new URL(connectionString);
+  return host.includes("localhost") || host.includes("127.0.0.1") || host.includes("[::1]");
+}

package/dist/chunk-LRBXMV4B.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 chunk_LRBXMV4B_exports = {};
+__export(chunk_LRBXMV4B_exports, {
+  maybeInGitHook: () => maybeInGitHook
+});
+module.exports = __toCommonJS(chunk_LRBXMV4B_exports);
+function maybeInGitHook() {
+  return process.env.GIT_EXEC_PATH !== void 0 || process.env.GIT_DIR !== void 0 || process.env.GIT_INDEX_FILE !== void 0 || process.env.GIT_PREFIX !== void 0;
+}

package/dist/chunk-LRU47BGE.js

@@ -0,0 +1,78 @@
+"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_LRU47BGE_exports = {};
+__export(chunk_LRU47BGE_exports, {
+  GeneratorConfigClass: () => GeneratorConfigClass,
+  getOriginalBinaryTargetsValue: () => getOriginalBinaryTargetsValue,
+  printDatamodelObject: () => printDatamodelObject,
+  printGeneratorConfig: () => printGeneratorConfig
+});
+module.exports = __toCommonJS(chunk_LRU47BGE_exports);
+var import_chunk_KDP6C3CB = require("./chunk-KDP6C3CB.js");
+var import_chunk_4VNS5WPM = require("./chunk-4VNS5WPM.js");
+var import_indent_string = (0, import_chunk_4VNS5WPM.__toESM)((0, import_chunk_KDP6C3CB.require_indent_string)());
+function printGeneratorConfig(config) {
+  return String(new GeneratorConfigClass(config));
+}
+var GeneratorConfigClass = class {
+  constructor(config) {
+    this.config = config;
+  }
+  toString() {
+    const { config } = this;
+    const provider = config.provider.fromEnvVar ? `env("${config.provider.fromEnvVar}")` : config.provider.value;
+    const obj = JSON.parse(
+      JSON.stringify({
+        provider,
+        binaryTargets: getOriginalBinaryTargetsValue(config.binaryTargets)
+      })
+    );
+    return `generator ${config.name} {
+${(0, import_indent_string.default)(printDatamodelObject(obj), 2)}
+}`;
+  }
+};
+function getOriginalBinaryTargetsValue(binaryTargets) {
+  let value;
+  if (binaryTargets.length > 0) {
+    const binaryTargetsFromEnvVar = binaryTargets.find((object) => object.fromEnvVar !== null);
+    if (binaryTargetsFromEnvVar) {
+      value = `env("${binaryTargetsFromEnvVar.fromEnvVar}")`;
+    } else {
+      value = binaryTargets.map((object) => object.native ? "native" : object.value);
+    }
+  } else {
+    value = void 0;
+  }
+  return value;
+}
+function printDatamodelObject(obj) {
+  const maxLength = Object.keys(obj).reduce((max, curr) => Math.max(max, curr.length), 0);
+  return Object.entries(obj).map(([key, value]) => `${key.padEnd(maxLength)} = ${niceStringify(value)}`).join("\n");
+}
+function niceStringify(value) {
+  return JSON.parse(
+    JSON.stringify(value, (_, value2) => {
+      if (Array.isArray(value2)) {
+        return `[${value2.map((element) => JSON.stringify(element)).join(", ")}]`;
+      }
+      return JSON.stringify(value2);
+    })
+  );
+}

package/dist/chunk-M3GBKLGE.js

@@ -0,0 +1,24 @@
+"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_M3GBKLGE_exports = {};
+__export(chunk_M3GBKLGE_exports, {
+  vercelPkgPathRegex: () => vercelPkgPathRegex
+});
+module.exports = __toCommonJS(chunk_M3GBKLGE_exports);
+var vercelPkgPathRegex = /^((\w:[\\\/])|\/)snapshot[\/\\]/;

package/dist/chunk-MCS5ZY6Y.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 chunk_MCS5ZY6Y_exports = {};
+__export(chunk_MCS5ZY6Y_exports, {
+  BuiltInProvider: () => BuiltInProvider
+});
+module.exports = __toCommonJS(chunk_MCS5ZY6Y_exports);
+var BuiltInProvider = {
+  PrismaClientJs: "prisma-client-js",
+  PrismaClientTs: "prisma-client"
+};

package/dist/chunk-NBWRGVYR.js

@@ -0,0 +1,47 @@
+"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_NBWRGVYR_exports = {};
+__export(chunk_NBWRGVYR_exports, {
+  inferDirectoryConfig: () => inferDirectoryConfig
+});
+module.exports = __toCommonJS(chunk_NBWRGVYR_exports);
+var import_node_path = __toESM(require("node:path"));
+function inferDirectoryConfig(schemaContext, config, cwd = process.cwd()) {
+  const baseDir = (
+    // If no primary datasource exists we use the schemaRootDir.
+    // `schemaRootDir` is either the directory the user supplied as schemaPath or the directory the single schema file is in.
+    schemaContext?.schemaRootDir ?? // Should also that not be defined because there is no schema yet we fallback to CWD + `/prisma`.
+    import_node_path.default.join(cwd, "prisma")
+  );
+  return {
+    viewsDirPath: config?.views?.path ?? import_node_path.default.join(baseDir, "views"),
+    typedSqlDirPath: config?.typedSql?.path ?? import_node_path.default.join(baseDir, "sql"),
+    migrationsDirPath: config?.migrations?.path ?? import_node_path.default.join(baseDir, "migrations")
+  };
+}

package/dist/chunk-NIWBAJZV.js

@@ -0,0 +1,36 @@
+"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_NIWBAJZV_exports = {};
+__export(chunk_NIWBAJZV_exports, {
+  callOnceOnSuccess: () => callOnceOnSuccess
+});
+module.exports = __toCommonJS(chunk_NIWBAJZV_exports);
+function callOnceOnSuccess(fn) {
+  let result;
+  return (...args) => {
+    if (result) {
+      return result;
+    }
+    result = fn(...args).catch((err) => {
+      result = void 0;
+      throw err;
+    });
+    return result;
+  };
+}