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

package/dist/chunk-I6WLABB2.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_I6WLABB2_exports = {};
+__export(chunk_I6WLABB2_exports, {
+  link: () => link2
+});
+module.exports = __toCommonJS(chunk_I6WLABB2_exports);
+var import_chunk_PG5FDKSF = require("./chunk-PG5FDKSF.js");
+var import_chunk_4VNS5WPM = require("./chunk-4VNS5WPM.js");
+var import_node_process = __toESM(require("node:process"));
+var require_has_flag = (0, import_chunk_4VNS5WPM.__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_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports, module2) {
+    "use strict";
+    var os = (0, import_chunk_4VNS5WPM.__require)("os");
+    var tty = (0, import_chunk_4VNS5WPM.__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_4VNS5WPM.__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_4VNS5WPM.__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_4VNS5WPM.__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: (url2) => (0, import_chunk_PG5FDKSF.underline)(url2)
+  });
+}

package/dist/chunk-ICFLO5JW.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_ICFLO5JW_exports = {};
+__export(chunk_ICFLO5JW_exports, {
+  isInteractive: () => isInteractive
+});
+module.exports = __toCommonJS(chunk_ICFLO5JW_exports);
+var isInteractive = ({ stream = process.stdin } = {}) => {
+  return Boolean(stream && stream.isTTY && process.env.TERM !== "dumb");
+};

package/dist/chunk-IL7PSY44.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_IL7PSY44_exports = {};
+__export(chunk_IL7PSY44_exports, {
+  assertNever: () => assertNever
+});
+module.exports = __toCommonJS(chunk_IL7PSY44_exports);
+function assertNever(arg, errorMessage) {
+  throw new Error(errorMessage);
+}

package/dist/chunk-IOIAK7V7.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_IOIAK7V7_exports = {};
+__export(chunk_IOIAK7V7_exports, {
+  parseBinaryTargetsEnvValue: () => parseBinaryTargetsEnvValue,
+  parseEnvValue: () => parseEnvValue
+});
+module.exports = __toCommonJS(chunk_IOIAK7V7_exports);
+var import_chunk_PG5FDKSF = require("./chunk-PG5FDKSF.js");
+function parseEnvValue(object) {
+  if (object.fromEnvVar && object.fromEnvVar != "null") {
+    const value = process.env[object.fromEnvVar];
+    if (!value) {
+      throw new Error(
+        `Attempted to load provider value using \`env(${object.fromEnvVar})\` but it was not present. Please ensure that ${(0, import_chunk_PG5FDKSF.dim)(
+          object.fromEnvVar
+        )} is present in your Environment Variables`
+      );
+    }
+    return value;
+  }
+  return object.value;
+}
+function parseBinaryTargetsEnvValue(object) {
+  if (object.fromEnvVar && object.fromEnvVar != "null") {
+    const value = process.env[object.fromEnvVar];
+    if (!value) {
+      throw new Error(
+        `Attempted to load binaryTargets value using \`env(${object.fromEnvVar})\` but it was not present. Please ensure that ${(0, import_chunk_PG5FDKSF.dim)(
+          object.fromEnvVar
+        )} is present in your Environment Variables`
+      );
+    }
+    return JSON.parse(value);
+  }
+  return object.value;
+}

package/dist/chunk-IYN5VKMD.js

@@ -0,0 +1,110 @@
+"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_IYN5VKMD_exports = {};
+__export(chunk_IYN5VKMD_exports, {
+  MergeSchemasError: () => MergeSchemasError,
+  mergeSchemas: () => mergeSchemas
+});
+module.exports = __toCommonJS(chunk_IYN5VKMD_exports);
+var import_chunk_6Z766KGR = require("./chunk-6Z766KGR.js");
+var import_chunk_C47SCASR = require("./chunk-C47SCASR.js");
+var import_chunk_R6QH57HZ = require("./chunk-R6QH57HZ.js");
+var import_chunk_I4K46RGG = require("./chunk-I4K46RGG.js");
+var import_chunk_L3LDE52J = require("./chunk-L3LDE52J.js");
+var import_chunk_5DBOS77Y = require("./chunk-5DBOS77Y.js");
+var import_chunk_YNDZCLVL = require("./chunk-YNDZCLVL.js");
+var import_chunk_LMVSIVKQ = require("./chunk-LMVSIVKQ.js");
+var import_chunk_PG5FDKSF = require("./chunk-PG5FDKSF.js");
+var import_chunk_4VNS5WPM = require("./chunk-4VNS5WPM.js");
+var import_debug = __toESM(require("@prisma/debug"));
+var import_function = (0, import_chunk_4VNS5WPM.__toESM)((0, import_chunk_R6QH57HZ.require_function)());
+var debug = (0, import_debug.default)("prisma:mergeSchemas");
+var MergeSchemasError = class extends Error {
+  constructor(params) {
+    const constructedErrorMessage = (0, import_chunk_YNDZCLVL.M)(params).with({ _tag: "parsed" }, ({ errorCode, message, reason }) => {
+      const errorCodeMessage = errorCode ? `Error code: ${errorCode}` : "";
+      return `${reason}
+${errorCodeMessage}
+${(0, import_chunk_C47SCASR.relativizePathInPSLError)(message)}`;
+    }).with({ _tag: "unparsed" }, ({ message, reason }) => {
+      const detailsHeader = (0, import_chunk_PG5FDKSF.red)((0, import_chunk_PG5FDKSF.bold)("Details:"));
+      return `${reason}
+${detailsHeader} ${message}`;
+    }).exhaustive();
+    const errorMessageWithContext = `${constructedErrorMessage}
+[Context: mergeSchemas]`;
+    super((0, import_chunk_I4K46RGG.addVersionDetailsToErrorMessage)(errorMessageWithContext));
+    this.name = "MergeSchemasError";
+  }
+};
+function mergeSchemas(options) {
+  const debugErrorType = (0, import_chunk_6Z766KGR.createDebugErrorType)(debug, "mergeSchemasWasm");
+  debug(`Using mergeSchemas Wasm`);
+  const mergeSchemasEither = (0, import_function.pipe)(
+    (0, import_chunk_5DBOS77Y.tryCatch)(
+      () => {
+        const params = JSON.stringify({
+          schema: options.schemas
+        });
+        return import_chunk_L3LDE52J.prismaSchemaWasm.merge_schemas(params);
+      },
+      (e) => ({
+        type: "wasm-error",
+        reason: "(mergeSchemas wasm)",
+        error: e
+      })
+    )
+  );
+  if ((0, import_chunk_5DBOS77Y.isRight)(mergeSchemasEither)) {
+    return mergeSchemasEither.right;
+  }
+  const error = (0, import_chunk_YNDZCLVL.M)(mergeSchemasEither.left).with({ type: "wasm-error" }, (e) => {
+    debugErrorType(e);
+    console.error("");
+    if ((0, import_chunk_LMVSIVKQ.isWasmPanic)(e.error)) {
+      const { message, stack } = (0, import_chunk_LMVSIVKQ.getWasmError)(e.error);
+      debug(`Error merging schemas: ${message}`);
+      debug(stack);
+      const panic = new import_chunk_LMVSIVKQ.RustPanic(
+        /* message */
+        message,
+        /* rustStack */
+        stack,
+        /* request */
+        "@prisma/prisma-schema-wasm merge_schemas",
+        "FMT_CLI"
+        /* FMT_CLI */
+      );
+      return panic;
+    }
+    const errorOutput = e.error.message;
+    return new MergeSchemasError((0, import_chunk_6Z766KGR.parseQueryEngineError)({ errorOutput, reason: e.reason }));
+  }).exhaustive();
+  throw error;
+}