@prisma/internals 6.6.0-dev.6 → 6.6.0-dev.60

package/dist/chunk-YR5KNFKN.js

@@ -0,0 +1,1834 @@
+"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 __toESM2 = (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_YR5KNFKN_exports = {};
+__export(chunk_YR5KNFKN_exports, {
+  sendPanic: () => sendPanic
+});
+module.exports = __toCommonJS(chunk_YR5KNFKN_exports);
+var import_chunk_KDHESRKE = require("./chunk-KDHESRKE.js");
+var import_chunk_ZSINRHD4 = require("./chunk-ZSINRHD4.js");
+var import_chunk_XKZ6CBLA = require("./chunk-XKZ6CBLA.js");
+var import_chunk_5AI4FIZ3 = require("./chunk-5AI4FIZ3.js");
+var import_chunk_4VNS5WPM = require("./chunk-4VNS5WPM.js");
+var import_get_platform = require("@prisma/get-platform");
+var import_os = __toESM2(require("os"));
+var require_vendors = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/ci-info@4.0.0/node_modules/ci-info/vendors.json"(exports2, module2) {
+    module2.exports = [
+      {
+        name: "Agola CI",
+        constant: "AGOLA",
+        env: "AGOLA_GIT_REF",
+        pr: "AGOLA_PULL_REQUEST_ID"
+      },
+      {
+        name: "Appcircle",
+        constant: "APPCIRCLE",
+        env: "AC_APPCIRCLE"
+      },
+      {
+        name: "AppVeyor",
+        constant: "APPVEYOR",
+        env: "APPVEYOR",
+        pr: "APPVEYOR_PULL_REQUEST_NUMBER"
+      },
+      {
+        name: "AWS CodeBuild",
+        constant: "CODEBUILD",
+        env: "CODEBUILD_BUILD_ARN"
+      },
+      {
+        name: "Azure Pipelines",
+        constant: "AZURE_PIPELINES",
+        env: "TF_BUILD",
+        pr: {
+          BUILD_REASON: "PullRequest"
+        }
+      },
+      {
+        name: "Bamboo",
+        constant: "BAMBOO",
+        env: "bamboo_planKey"
+      },
+      {
+        name: "Bitbucket Pipelines",
+        constant: "BITBUCKET",
+        env: "BITBUCKET_COMMIT",
+        pr: "BITBUCKET_PR_ID"
+      },
+      {
+        name: "Bitrise",
+        constant: "BITRISE",
+        env: "BITRISE_IO",
+        pr: "BITRISE_PULL_REQUEST"
+      },
+      {
+        name: "Buddy",
+        constant: "BUDDY",
+        env: "BUDDY_WORKSPACE_ID",
+        pr: "BUDDY_EXECUTION_PULL_REQUEST_ID"
+      },
+      {
+        name: "Buildkite",
+        constant: "BUILDKITE",
+        env: "BUILDKITE",
+        pr: {
+          env: "BUILDKITE_PULL_REQUEST",
+          ne: "false"
+        }
+      },
+      {
+        name: "CircleCI",
+        constant: "CIRCLE",
+        env: "CIRCLECI",
+        pr: "CIRCLE_PULL_REQUEST"
+      },
+      {
+        name: "Cirrus CI",
+        constant: "CIRRUS",
+        env: "CIRRUS_CI",
+        pr: "CIRRUS_PR"
+      },
+      {
+        name: "Codefresh",
+        constant: "CODEFRESH",
+        env: "CF_BUILD_ID",
+        pr: {
+          any: [
+            "CF_PULL_REQUEST_NUMBER",
+            "CF_PULL_REQUEST_ID"
+          ]
+        }
+      },
+      {
+        name: "Codemagic",
+        constant: "CODEMAGIC",
+        env: "CM_BUILD_ID",
+        pr: "CM_PULL_REQUEST"
+      },
+      {
+        name: "Codeship",
+        constant: "CODESHIP",
+        env: {
+          CI_NAME: "codeship"
+        }
+      },
+      {
+        name: "Drone",
+        constant: "DRONE",
+        env: "DRONE",
+        pr: {
+          DRONE_BUILD_EVENT: "pull_request"
+        }
+      },
+      {
+        name: "dsari",
+        constant: "DSARI",
+        env: "DSARI"
+      },
+      {
+        name: "Earthly",
+        constant: "EARTHLY",
+        env: "EARTHLY_CI"
+      },
+      {
+        name: "Expo Application Services",
+        constant: "EAS",
+        env: "EAS_BUILD"
+      },
+      {
+        name: "Gerrit",
+        constant: "GERRIT",
+        env: "GERRIT_PROJECT"
+      },
+      {
+        name: "Gitea Actions",
+        constant: "GITEA_ACTIONS",
+        env: "GITEA_ACTIONS"
+      },
+      {
+        name: "GitHub Actions",
+        constant: "GITHUB_ACTIONS",
+        env: "GITHUB_ACTIONS",
+        pr: {
+          GITHUB_EVENT_NAME: "pull_request"
+        }
+      },
+      {
+        name: "GitLab CI",
+        constant: "GITLAB",
+        env: "GITLAB_CI",
+        pr: "CI_MERGE_REQUEST_ID"
+      },
+      {
+        name: "GoCD",
+        constant: "GOCD",
+        env: "GO_PIPELINE_LABEL"
+      },
+      {
+        name: "Google Cloud Build",
+        constant: "GOOGLE_CLOUD_BUILD",
+        env: "BUILDER_OUTPUT"
+      },
+      {
+        name: "Harness CI",
+        constant: "HARNESS",
+        env: "HARNESS_BUILD_ID"
+      },
+      {
+        name: "Heroku",
+        constant: "HEROKU",
+        env: {
+          env: "NODE",
+          includes: "/app/.heroku/node/bin/node"
+        }
+      },
+      {
+        name: "Hudson",
+        constant: "HUDSON",
+        env: "HUDSON_URL"
+      },
+      {
+        name: "Jenkins",
+        constant: "JENKINS",
+        env: [
+          "JENKINS_URL",
+          "BUILD_ID"
+        ],
+        pr: {
+          any: [
+            "ghprbPullId",
+            "CHANGE_ID"
+          ]
+        }
+      },
+      {
+        name: "LayerCI",
+        constant: "LAYERCI",
+        env: "LAYERCI",
+        pr: "LAYERCI_PULL_REQUEST"
+      },
+      {
+        name: "Magnum CI",
+        constant: "MAGNUM",
+        env: "MAGNUM"
+      },
+      {
+        name: "Netlify CI",
+        constant: "NETLIFY",
+        env: "NETLIFY",
+        pr: {
+          env: "PULL_REQUEST",
+          ne: "false"
+        }
+      },
+      {
+        name: "Nevercode",
+        constant: "NEVERCODE",
+        env: "NEVERCODE",
+        pr: {
+          env: "NEVERCODE_PULL_REQUEST",
+          ne: "false"
+        }
+      },
+      {
+        name: "Prow",
+        constant: "PROW",
+        env: "PROW_JOB_ID"
+      },
+      {
+        name: "ReleaseHub",
+        constant: "RELEASEHUB",
+        env: "RELEASE_BUILD_ID"
+      },
+      {
+        name: "Render",
+        constant: "RENDER",
+        env: "RENDER",
+        pr: {
+          IS_PULL_REQUEST: "true"
+        }
+      },
+      {
+        name: "Sail CI",
+        constant: "SAIL",
+        env: "SAILCI",
+        pr: "SAIL_PULL_REQUEST_NUMBER"
+      },
+      {
+        name: "Screwdriver",
+        constant: "SCREWDRIVER",
+        env: "SCREWDRIVER",
+        pr: {
+          env: "SD_PULL_REQUEST",
+          ne: "false"
+        }
+      },
+      {
+        name: "Semaphore",
+        constant: "SEMAPHORE",
+        env: "SEMAPHORE",
+        pr: "PULL_REQUEST_NUMBER"
+      },
+      {
+        name: "Sourcehut",
+        constant: "SOURCEHUT",
+        env: {
+          CI_NAME: "sourcehut"
+        }
+      },
+      {
+        name: "Strider CD",
+        constant: "STRIDER",
+        env: "STRIDER"
+      },
+      {
+        name: "TaskCluster",
+        constant: "TASKCLUSTER",
+        env: [
+          "TASK_ID",
+          "RUN_ID"
+        ]
+      },
+      {
+        name: "TeamCity",
+        constant: "TEAMCITY",
+        env: "TEAMCITY_VERSION"
+      },
+      {
+        name: "Travis CI",
+        constant: "TRAVIS",
+        env: "TRAVIS",
+        pr: {
+          env: "TRAVIS_PULL_REQUEST",
+          ne: "false"
+        }
+      },
+      {
+        name: "Vela",
+        constant: "VELA",
+        env: "VELA",
+        pr: {
+          VELA_PULL_REQUEST: "1"
+        }
+      },
+      {
+        name: "Vercel",
+        constant: "VERCEL",
+        env: {
+          any: [
+            "NOW_BUILDER",
+            "VERCEL"
+          ]
+        },
+        pr: "VERCEL_GIT_PULL_REQUEST_ID"
+      },
+      {
+        name: "Visual Studio App Center",
+        constant: "APPCENTER",
+        env: "APPCENTER_BUILD_ID"
+      },
+      {
+        name: "Woodpecker",
+        constant: "WOODPECKER",
+        env: {
+          CI: "woodpecker"
+        },
+        pr: {
+          CI_BUILD_EVENT: "pull_request"
+        }
+      },
+      {
+        name: "Xcode Cloud",
+        constant: "XCODE_CLOUD",
+        env: "CI_XCODE_PROJECT",
+        pr: "CI_PULL_REQUEST_NUMBER"
+      },
+      {
+        name: "Xcode Server",
+        constant: "XCODE_SERVER",
+        env: "XCS"
+      }
+    ];
+  }
+});
+var require_ci_info = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/ci-info@4.0.0/node_modules/ci-info/index.js"(exports2) {
+    "use strict";
+    var vendors = require_vendors();
+    var env2 = process.env;
+    Object.defineProperty(exports2, "_vendors", {
+      value: vendors.map(function(v) {
+        return v.constant;
+      })
+    });
+    exports2.name = null;
+    exports2.isPR = null;
+    vendors.forEach(function(vendor) {
+      const envs = Array.isArray(vendor.env) ? vendor.env : [vendor.env];
+      const isCI = envs.every(function(obj) {
+        return checkEnv(obj);
+      });
+      exports2[vendor.constant] = isCI;
+      if (!isCI) {
+        return;
+      }
+      exports2.name = vendor.name;
+      switch (typeof vendor.pr) {
+        case "string":
+          exports2.isPR = !!env2[vendor.pr];
+          break;
+        case "object":
+          if ("env" in vendor.pr) {
+            exports2.isPR = vendor.pr.env in env2 && env2[vendor.pr.env] !== vendor.pr.ne;
+          } else if ("any" in vendor.pr) {
+            exports2.isPR = vendor.pr.any.some(function(key) {
+              return !!env2[key];
+            });
+          } else {
+            exports2.isPR = checkEnv(vendor.pr);
+          }
+          break;
+        default:
+          exports2.isPR = null;
+      }
+    });
+    exports2.isCI = !!(env2.CI !== "false" && // Bypass all checks if CI env is explicitly set to 'false'
+    (env2.BUILD_ID || // Jenkins, Cloudbees
+    env2.BUILD_NUMBER || // Jenkins, TeamCity
+    env2.CI || // Travis CI, CircleCI, Cirrus CI, Gitlab CI, Appveyor, CodeShip, dsari
+    env2.CI_APP_ID || // Appflow
+    env2.CI_BUILD_ID || // Appflow
+    env2.CI_BUILD_NUMBER || // Appflow
+    env2.CI_NAME || // Codeship and others
+    env2.CONTINUOUS_INTEGRATION || // Travis CI, Cirrus CI
+    env2.RUN_ID || // TaskCluster, dsari
+    exports2.name || false));
+    function checkEnv(obj) {
+      if (typeof obj === "string") return !!env2[obj];
+      if ("env" in obj) {
+        return env2[obj.env] && env2[obj.env].includes(obj.includes);
+      }
+      if ("any" in obj) {
+        return obj.any.some(function(k) {
+          return !!env2[k];
+        });
+      }
+      return Object.keys(obj).every(function(k) {
+        return env2[k] === obj[k];
+      });
+    }
+  }
+});
+var require_dist = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/checkpoint-client@1.1.33_encoding@0.1.13/node_modules/checkpoint-client/dist/index.js"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var path$2 = (0, import_chunk_4VNS5WPM.__require)("path");
+    var os$1 = (0, import_chunk_4VNS5WPM.__require)("os");
+    var require$$0 = (0, import_chunk_4VNS5WPM.__require)("fs");
+    var require$$2 = (0, import_chunk_4VNS5WPM.__require)("util");
+    var fs$1 = (0, import_chunk_4VNS5WPM.__require)("fs/promises");
+    var crypto = (0, import_chunk_4VNS5WPM.__require)("crypto");
+    var child_process = (0, import_chunk_4VNS5WPM.__require)("child_process");
+    function _interopDefaultLegacy(e) {
+      return e && typeof e === "object" && "default" in e ? e : { "default": e };
+    }
+    var path__default = /* @__PURE__ */ _interopDefaultLegacy(path$2);
+    var os__default = /* @__PURE__ */ _interopDefaultLegacy(os$1);
+    var require$$0__default = /* @__PURE__ */ _interopDefaultLegacy(require$$0);
+    var require$$2__default = /* @__PURE__ */ _interopDefaultLegacy(require$$2);
+    var fs__default = /* @__PURE__ */ _interopDefaultLegacy(fs$1);
+    var crypto__default = /* @__PURE__ */ _interopDefaultLegacy(crypto);
+    var rnds8Pool = new Uint8Array(256);
+    var poolPtr = rnds8Pool.length;
+    function rng() {
+      if (poolPtr > rnds8Pool.length - 16) {
+        crypto__default["default"].randomFillSync(rnds8Pool);
+        poolPtr = 0;
+      }
+      return rnds8Pool.slice(poolPtr, poolPtr += 16);
+    }
+    var byteToHex = [];
+    for (let i = 0; i < 256; ++i) {
+      byteToHex.push((i + 256).toString(16).slice(1));
+    }
+    function unsafeStringify(arr, offset = 0) {
+      return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+    }
+    var native = {
+      randomUUID: crypto__default["default"].randomUUID
+    };
+    function v4(options, buf, offset) {
+      if (native.randomUUID && !buf && !options) {
+        return native.randomUUID();
+      }
+      options = options || {};
+      const rnds = options.random || (options.rng || rng)();
+      rnds[6] = rnds[6] & 15 | 64;
+      rnds[8] = rnds[8] & 63 | 128;
+      if (buf) {
+        offset = offset || 0;
+        for (let i = 0; i < 16; ++i) {
+          buf[offset + i] = rnds[i];
+        }
+        return buf;
+      }
+      return unsafeStringify(rnds);
+    }
+    var envPaths$1 = { exports: {} };
+    var path$1 = path__default["default"];
+    var os = os__default["default"];
+    var homedir = os.homedir();
+    var tmpdir = os.tmpdir();
+    var { env } = process;
+    var macos = (name) => {
+      const library = path$1.join(homedir, "Library");
+      return {
+        data: path$1.join(library, "Application Support", name),
+        config: path$1.join(library, "Preferences", name),
+        cache: path$1.join(library, "Caches", name),
+        log: path$1.join(library, "Logs", name),
+        temp: path$1.join(tmpdir, name)
+      };
+    };
+    var windows = (name) => {
+      const appData = env.APPDATA || path$1.join(homedir, "AppData", "Roaming");
+      const localAppData = env.LOCALAPPDATA || path$1.join(homedir, "AppData", "Local");
+      return {
+        // Data/config/cache/log are invented by me as Windows isn't opinionated about this
+        data: path$1.join(localAppData, name, "Data"),
+        config: path$1.join(appData, name, "Config"),
+        cache: path$1.join(localAppData, name, "Cache"),
+        log: path$1.join(localAppData, name, "Log"),
+        temp: path$1.join(tmpdir, name)
+      };
+    };
+    var linux = (name) => {
+      const username = path$1.basename(homedir);
+      return {
+        data: path$1.join(env.XDG_DATA_HOME || path$1.join(homedir, ".local", "share"), name),
+        config: path$1.join(env.XDG_CONFIG_HOME || path$1.join(homedir, ".config"), name),
+        cache: path$1.join(env.XDG_CACHE_HOME || path$1.join(homedir, ".cache"), name),
+        // https://wiki.debian.org/XDGBaseDirectorySpecification#state
+        log: path$1.join(env.XDG_STATE_HOME || path$1.join(homedir, ".local", "state"), name),
+        temp: path$1.join(tmpdir, username, name)
+      };
+    };
+    var envPaths = (name, options) => {
+      if (typeof name !== "string") {
+        throw new TypeError(`Expected string, got ${typeof name}`);
+      }
+      options = Object.assign({ suffix: "nodejs" }, options);
+      if (options.suffix) {
+        name += `-${options.suffix}`;
+      }
+      if (process.platform === "darwin") {
+        return macos(name);
+      }
+      if (process.platform === "win32") {
+        return windows(name);
+      }
+      return linux(name);
+    };
+    envPaths$1.exports = envPaths;
+    envPaths$1.exports.default = envPaths;
+    var paths = envPaths$1.exports;
+    var makeDir$2 = { exports: {} };
+    var debug$1 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+    };
+    var debug_1 = debug$1;
+    var SEMVER_SPEC_VERSION = "2.0.0";
+    var MAX_LENGTH$1 = 256;
+    var MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+    9007199254740991;
+    var MAX_SAFE_COMPONENT_LENGTH = 16;
+    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH$1 - 6;
+    var RELEASE_TYPES = [
+      "major",
+      "premajor",
+      "minor",
+      "preminor",
+      "patch",
+      "prepatch",
+      "prerelease"
+    ];
+    var constants = {
+      MAX_LENGTH: MAX_LENGTH$1,
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
+      RELEASE_TYPES,
+      SEMVER_SPEC_VERSION,
+      FLAG_INCLUDE_PRERELEASE: 1,
+      FLAG_LOOSE: 2
+    };
+    var re$1 = { exports: {} };
+    (function(module2, exports2) {
+      const { MAX_SAFE_COMPONENT_LENGTH: MAX_SAFE_COMPONENT_LENGTH2, MAX_SAFE_BUILD_LENGTH: MAX_SAFE_BUILD_LENGTH2 } = constants;
+      const debug2 = debug_1;
+      exports2 = module2.exports = {};
+      const re2 = exports2.re = [];
+      const safeRe = exports2.safeRe = [];
+      const src = exports2.src = [];
+      const t2 = exports2.t = {};
+      let R = 0;
+      const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+      const safeRegexReplacements = [
+        ["\\s", 1],
+        ["\\d", MAX_SAFE_COMPONENT_LENGTH2],
+        [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH2]
+      ];
+      const makeSafeRegex = (value) => {
+        for (const [token, max] of safeRegexReplacements) {
+          value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+        }
+        return value;
+      };
+      const createToken = (name, value, isGlobal) => {
+        const safe = makeSafeRegex(value);
+        const index = R++;
+        debug2(name, index, value);
+        t2[name] = index;
+        src[index] = value;
+        re2[index] = new RegExp(value, isGlobal ? "g" : void 0);
+        safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+      };
+      createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+      createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+      createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+      createToken("MAINVERSION", `(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})`);
+      createToken("MAINVERSIONLOOSE", `(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})`);
+      createToken("PRERELEASEIDENTIFIER", `(?:${src[t2.NUMERICIDENTIFIER]}|${src[t2.NONNUMERICIDENTIFIER]})`);
+      createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t2.NUMERICIDENTIFIERLOOSE]}|${src[t2.NONNUMERICIDENTIFIER]})`);
+      createToken("PRERELEASE", `(?:-(${src[t2.PRERELEASEIDENTIFIER]}(?:\\.${src[t2.PRERELEASEIDENTIFIER]})*))`);
+      createToken("PRERELEASELOOSE", `(?:-?(${src[t2.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t2.PRERELEASEIDENTIFIERLOOSE]})*))`);
+      createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+      createToken("BUILD", `(?:\\+(${src[t2.BUILDIDENTIFIER]}(?:\\.${src[t2.BUILDIDENTIFIER]})*))`);
+      createToken("FULLPLAIN", `v?${src[t2.MAINVERSION]}${src[t2.PRERELEASE]}?${src[t2.BUILD]}?`);
+      createToken("FULL", `^${src[t2.FULLPLAIN]}$`);
+      createToken("LOOSEPLAIN", `[v=\\s]*${src[t2.MAINVERSIONLOOSE]}${src[t2.PRERELEASELOOSE]}?${src[t2.BUILD]}?`);
+      createToken("LOOSE", `^${src[t2.LOOSEPLAIN]}$`);
+      createToken("GTLT", "((?:<|>)?=?)");
+      createToken("XRANGEIDENTIFIERLOOSE", `${src[t2.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+      createToken("XRANGEIDENTIFIER", `${src[t2.NUMERICIDENTIFIER]}|x|X|\\*`);
+      createToken("XRANGEPLAIN", `[v=\\s]*(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:${src[t2.PRERELEASE]})?${src[t2.BUILD]}?)?)?`);
+      createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:${src[t2.PRERELEASELOOSE]})?${src[t2.BUILD]}?)?)?`);
+      createToken("XRANGE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAIN]}$`);
+      createToken("XRANGELOOSE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAINLOOSE]}$`);
+      createToken("COERCE", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH2}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?(?:$|[^\\d])`);
+      createToken("COERCERTL", src[t2.COERCE], true);
+      createToken("LONETILDE", "(?:~>?)");
+      createToken("TILDETRIM", `(\\s*)${src[t2.LONETILDE]}\\s+`, true);
+      exports2.tildeTrimReplace = "$1~";
+      createToken("TILDE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAIN]}$`);
+      createToken("TILDELOOSE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAINLOOSE]}$`);
+      createToken("LONECARET", "(?:\\^)");
+      createToken("CARETTRIM", `(\\s*)${src[t2.LONECARET]}\\s+`, true);
+      exports2.caretTrimReplace = "$1^";
+      createToken("CARET", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAIN]}$`);
+      createToken("CARETLOOSE", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAINLOOSE]}$`);
+      createToken("COMPARATORLOOSE", `^${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]})$|^$`);
+      createToken("COMPARATOR", `^${src[t2.GTLT]}\\s*(${src[t2.FULLPLAIN]})$|^$`);
+      createToken("COMPARATORTRIM", `(\\s*)${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]}|${src[t2.XRANGEPLAIN]})`, true);
+      exports2.comparatorTrimReplace = "$1$2$3";
+      createToken("HYPHENRANGE", `^\\s*(${src[t2.XRANGEPLAIN]})\\s+-\\s+(${src[t2.XRANGEPLAIN]})\\s*$`);
+      createToken("HYPHENRANGELOOSE", `^\\s*(${src[t2.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t2.XRANGEPLAINLOOSE]})\\s*$`);
+      createToken("STAR", "(<|>)?=?\\s*\\*");
+      createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+      createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+    })(re$1, re$1.exports);
+    var looseOption = Object.freeze({ loose: true });
+    var emptyOpts = Object.freeze({});
+    var parseOptions$1 = (options) => {
+      if (!options) {
+        return emptyOpts;
+      }
+      if (typeof options !== "object") {
+        return looseOption;
+      }
+      return options;
+    };
+    var parseOptions_1 = parseOptions$1;
+    var numeric = /^[0-9]+$/;
+    var compareIdentifiers$1 = (a, b) => {
+      const anum = numeric.test(a);
+      const bnum = numeric.test(b);
+      if (anum && bnum) {
+        a = +a;
+        b = +b;
+      }
+      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+    };
+    var rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a);
+    var identifiers = {
+      compareIdentifiers: compareIdentifiers$1,
+      rcompareIdentifiers
+    };
+    var debug = debug_1;
+    var { MAX_LENGTH, MAX_SAFE_INTEGER } = constants;
+    var { safeRe: re, t } = re$1.exports;
+    var parseOptions = parseOptions_1;
+    var { compareIdentifiers } = identifiers;
+    var SemVer$1 = class _SemVer$1 {
+      constructor(version, options) {
+        options = parseOptions(options);
+        if (version instanceof _SemVer$1) {
+          if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
+            return version;
+          } else {
+            version = version.version;
+          }
+        } else if (typeof version !== "string") {
+          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+        }
+        if (version.length > MAX_LENGTH) {
+          throw new TypeError(
+            `version is longer than ${MAX_LENGTH} characters`
+          );
+        }
+        debug("SemVer", version, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        const m2 = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+        if (!m2) {
+          throw new TypeError(`Invalid Version: ${version}`);
+        }
+        this.raw = version;
+        this.major = +m2[1];
+        this.minor = +m2[2];
+        this.patch = +m2[3];
+        if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+          throw new TypeError("Invalid major version");
+        }
+        if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+          throw new TypeError("Invalid minor version");
+        }
+        if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+          throw new TypeError("Invalid patch version");
+        }
+        if (!m2[4]) {
+          this.prerelease = [];
+        } else {
+          this.prerelease = m2[4].split(".").map((id) => {
+            if (/^[0-9]+$/.test(id)) {
+              const num = +id;
+              if (num >= 0 && num < MAX_SAFE_INTEGER) {
+                return num;
+              }
+            }
+            return id;
+          });
+        }
+        this.build = m2[5] ? m2[5].split(".") : [];
+        this.format();
+      }
+      format() {
+        this.version = `${this.major}.${this.minor}.${this.patch}`;
+        if (this.prerelease.length) {
+          this.version += `-${this.prerelease.join(".")}`;
+        }
+        return this.version;
+      }
+      toString() {
+        return this.version;
+      }
+      compare(other) {
+        debug("SemVer.compare", this.version, this.options, other);
+        if (!(other instanceof _SemVer$1)) {
+          if (typeof other === "string" && other === this.version) {
+            return 0;
+          }
+          other = new _SemVer$1(other, this.options);
+        }
+        if (other.version === this.version) {
+          return 0;
+        }
+        return this.compareMain(other) || this.comparePre(other);
+      }
+      compareMain(other) {
+        if (!(other instanceof _SemVer$1)) {
+          other = new _SemVer$1(other, this.options);
+        }
+        return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
+      }
+      comparePre(other) {
+        if (!(other instanceof _SemVer$1)) {
+          other = new _SemVer$1(other, this.options);
+        }
+        if (this.prerelease.length && !other.prerelease.length) {
+          return -1;
+        } else if (!this.prerelease.length && other.prerelease.length) {
+          return 1;
+        } else if (!this.prerelease.length && !other.prerelease.length) {
+          return 0;
+        }
+        let i = 0;
+        do {
+          const a = this.prerelease[i];
+          const b = other.prerelease[i];
+          debug("prerelease compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
+          } else {
+            return compareIdentifiers(a, b);
+          }
+        } while (++i);
+      }
+      compareBuild(other) {
+        if (!(other instanceof _SemVer$1)) {
+          other = new _SemVer$1(other, this.options);
+        }
+        let i = 0;
+        do {
+          const a = this.build[i];
+          const b = other.build[i];
+          debug("prerelease compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
+          } else {
+            return compareIdentifiers(a, b);
+          }
+        } while (++i);
+      }
+      // preminor will bump the version up to the next minor release, and immediately
+      // down to pre-release. premajor and prepatch work the same way.
+      inc(release, identifier, identifierBase) {
+        switch (release) {
+          case "premajor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor = 0;
+            this.major++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "preminor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "prepatch":
+            this.prerelease.length = 0;
+            this.inc("patch", identifier, identifierBase);
+            this.inc("pre", identifier, identifierBase);
+            break;
+          // If the input is a non-prerelease version, this acts the same as
+          // prepatch.
+          case "prerelease":
+            if (this.prerelease.length === 0) {
+              this.inc("patch", identifier, identifierBase);
+            }
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "major":
+            if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+              this.major++;
+            }
+            this.minor = 0;
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "minor":
+            if (this.patch !== 0 || this.prerelease.length === 0) {
+              this.minor++;
+            }
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "patch":
+            if (this.prerelease.length === 0) {
+              this.patch++;
+            }
+            this.prerelease = [];
+            break;
+          // This probably shouldn't be used publicly.
+          // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+          case "pre": {
+            const base = Number(identifierBase) ? 1 : 0;
+            if (!identifier && identifierBase === false) {
+              throw new Error("invalid increment argument: identifier is empty");
+            }
+            if (this.prerelease.length === 0) {
+              this.prerelease = [base];
+            } else {
+              let i = this.prerelease.length;
+              while (--i >= 0) {
+                if (typeof this.prerelease[i] === "number") {
+                  this.prerelease[i]++;
+                  i = -2;
+                }
+              }
+              if (i === -1) {
+                if (identifier === this.prerelease.join(".") && identifierBase === false) {
+                  throw new Error("invalid increment argument: identifier already exists");
+                }
+                this.prerelease.push(base);
+              }
+            }
+            if (identifier) {
+              let prerelease = [identifier, base];
+              if (identifierBase === false) {
+                prerelease = [identifier];
+              }
+              if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+                if (isNaN(this.prerelease[1])) {
+                  this.prerelease = prerelease;
+                }
+              } else {
+                this.prerelease = prerelease;
+              }
+            }
+            break;
+          }
+          default:
+            throw new Error(`invalid increment argument: ${release}`);
+        }
+        this.raw = this.format();
+        if (this.build.length) {
+          this.raw += `+${this.build.join(".")}`;
+        }
+        return this;
+      }
+    };
+    var semver = SemVer$1;
+    var SemVer = semver;
+    var compare$1 = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+    var compare_1 = compare$1;
+    var compare = compare_1;
+    var gte = (a, b, loose) => compare(a, b, loose) >= 0;
+    var gte_1 = gte;
+    var fs = require$$0__default["default"];
+    var path = path__default["default"];
+    var { promisify } = require$$2__default["default"];
+    var semverGte = gte_1;
+    var useNativeRecursiveOption = semverGte(process.version, "10.12.0");
+    var checkPath = (pth) => {
+      if (process.platform === "win32") {
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ""));
+        if (pathHasInvalidWinCharacters) {
+          const error = new Error(`Path contains invalid characters: ${pth}`);
+          error.code = "EINVAL";
+          throw error;
+        }
+      }
+    };
+    var processOptions = (options) => {
+      const defaults = {
+        mode: 511,
+        fs
+      };
+      return {
+        ...defaults,
+        ...options
+      };
+    };
+    var permissionError = (pth) => {
+      const error = new Error(`operation not permitted, mkdir '${pth}'`);
+      error.code = "EPERM";
+      error.errno = -4048;
+      error.path = pth;
+      error.syscall = "mkdir";
+      return error;
+    };
+    var makeDir = async (input, options) => {
+      checkPath(input);
+      options = processOptions(options);
+      const mkdir = promisify(options.fs.mkdir);
+      const stat = promisify(options.fs.stat);
+      if (useNativeRecursiveOption && options.fs.mkdir === fs.mkdir) {
+        const pth = path.resolve(input);
+        await mkdir(pth, {
+          mode: options.mode,
+          recursive: true
+        });
+        return pth;
+      }
+      const make = async (pth) => {
+        try {
+          await mkdir(pth, options.mode);
+          return pth;
+        } catch (error) {
+          if (error.code === "EPERM") {
+            throw error;
+          }
+          if (error.code === "ENOENT") {
+            if (path.dirname(pth) === pth) {
+              throw permissionError(pth);
+            }
+            if (error.message.includes("null bytes")) {
+              throw error;
+            }
+            await make(path.dirname(pth));
+            return make(pth);
+          }
+          try {
+            const stats = await stat(pth);
+            if (!stats.isDirectory()) {
+              throw new Error("The path is not a directory");
+            }
+          } catch {
+            throw error;
+          }
+          return pth;
+        }
+      };
+      return make(path.resolve(input));
+    };
+    makeDir$2.exports = makeDir;
+    makeDir$2.exports.sync = (input, options) => {
+      checkPath(input);
+      options = processOptions(options);
+      if (useNativeRecursiveOption && options.fs.mkdirSync === fs.mkdirSync) {
+        const pth = path.resolve(input);
+        fs.mkdirSync(pth, {
+          mode: options.mode,
+          recursive: true
+        });
+        return pth;
+      }
+      const make = (pth) => {
+        try {
+          options.fs.mkdirSync(pth, options.mode);
+        } catch (error) {
+          if (error.code === "EPERM") {
+            throw error;
+          }
+          if (error.code === "ENOENT") {
+            if (path.dirname(pth) === pth) {
+              throw permissionError(pth);
+            }
+            if (error.message.includes("null bytes")) {
+              throw error;
+            }
+            make(path.dirname(pth));
+            return make(pth);
+          }
+          try {
+            if (!options.fs.statSync(pth).isDirectory()) {
+              throw new Error("The path is not a directory");
+            }
+          } catch {
+            throw error;
+          }
+        }
+        return pth;
+      };
+      return make(path.resolve(input));
+    };
+    var makeDir$1 = makeDir$2.exports;
+    var PRISMA_SIGNATURE = "signature";
+    async function getSignature(signatureFile) {
+      const dirs = paths("checkpoint");
+      signatureFile = signatureFile || path__default["default"].join(dirs.cache, PRISMA_SIGNATURE);
+      const signature = await readSignature(signatureFile);
+      if (signature) {
+        return signature;
+      }
+      return await createSignatureFile(signatureFile);
+    }
+    function isSignatureValid(signature) {
+      return typeof signature === "string" && signature.length === 36;
+    }
+    async function readSignature(file) {
+      try {
+        const data = await fs__default["default"].readFile(file, "utf8");
+        const { signature } = JSON.parse(data);
+        if (isSignatureValid(signature)) {
+          return signature;
+        }
+        return "";
+      } catch (err) {
+        return "";
+      }
+    }
+    async function createSignatureFile(signatureFile, signature) {
+      const signatureState = {
+        signature: signature || v4()
+      };
+      await makeDir$1(path__default["default"].dirname(signatureFile));
+      await fs__default["default"].writeFile(signatureFile, JSON.stringify(signatureState, null, "  "));
+      return signatureState.signature;
+    }
+    async function getInfo() {
+      const cachePath = paths("checkpoint").cache;
+      if (!require$$0.existsSync(cachePath)) {
+        await fs__default["default"].mkdir(cachePath, { recursive: true });
+      }
+      const dir = await fs__default["default"].readdir(cachePath);
+      const cacheItems = [];
+      for (const item of dir) {
+        if (!item.includes("-")) {
+          continue;
+        }
+        try {
+          const jsonData = JSON.parse(await fs__default["default"].readFile(path__default["default"].join(cachePath, item), { encoding: "utf-8" }));
+          if (jsonData.output && !jsonData.output.cli_path_hash) {
+            jsonData.output.cli_path_hash = item.split("-")[1];
+          }
+          cacheItems.push(jsonData);
+        } catch (e) {
+          console.error(e);
+        }
+      }
+      return {
+        signature: await getSignature(),
+        cachePath,
+        cacheItems
+      };
+    }
+    var defaultSchema = {
+      last_reminder: 0,
+      cached_at: 0,
+      version: "",
+      cli_path: "",
+      // User output
+      output: {
+        client_event_id: "",
+        previous_client_event_id: "",
+        product: "",
+        cli_path_hash: "",
+        local_timestamp: "",
+        previous_version: "",
+        current_version: "",
+        current_release_date: 0,
+        current_download_url: "",
+        current_changelog_url: "",
+        package: "",
+        release_tag: "",
+        install_command: "",
+        project_website: "",
+        outdated: false,
+        alerts: []
+      }
+    };
+    var Config = class _Config {
+      static async new(state, schema = defaultSchema) {
+        await makeDir$1(path__default["default"].dirname(state.cache_file));
+        return new _Config(state, schema);
+      }
+      constructor(state, defaultSchema2) {
+        this.state = state;
+        this.defaultSchema = defaultSchema2;
+      }
+      // check and return the cache if (matches version or hasn't expired)
+      async checkCache(newState) {
+        const now = newState.now();
+        const cache = await this.all();
+        if (!cache) {
+          return { cache: void 0, stale: true };
+        }
+        if (newState.version !== cache.version) {
+          return { cache, stale: true };
+        }
+        if (now - cache.cached_at > newState.cache_duration) {
+          return { cache, stale: true };
+        }
+        return { cache, stale: false };
+      }
+      // set the configuration
+      async set(update) {
+        const existing = await this.all() || {};
+        const schema = Object.assign(existing, update);
+        for (let k in this.defaultSchema) {
+          if (typeof schema[k] === "undefined") {
+            schema[k] = this.defaultSchema[k];
+          }
+        }
+        await fs__default["default"].writeFile(this.state.cache_file, JSON.stringify(schema, null, "  "));
+      }
+      // get the entire schema
+      async all() {
+        try {
+          const data = await fs__default["default"].readFile(this.state.cache_file, "utf8");
+          return JSON.parse(data);
+        } catch (err) {
+          return;
+        }
+      }
+      // get a value from the schema
+      async get(key) {
+        const schema = await this.all();
+        if (typeof schema === "undefined") {
+          return;
+        }
+        return schema[key];
+      }
+      // reset the configuration
+      async reset() {
+        await fs__default["default"].writeFile(this.state.cache_file, JSON.stringify(this.defaultSchema, null, "  "));
+        return;
+      }
+      // delete the configuration, ignoring any errors
+      async delete() {
+        try {
+          await fs__default["default"].unlink(this.state.cache_file);
+          return;
+        } catch (err) {
+          return;
+        }
+      }
+    };
+    var s = 1e3;
+    var m = s * 60;
+    var h = m * 60;
+    var d = h * 24;
+    var w = d * 7;
+    var y = d * 365.25;
+    var ms = function(val, options) {
+      options = options || {};
+      var type = typeof val;
+      if (type === "string" && val.length > 0) {
+        return parse(val);
+      } else if (type === "number" && isFinite(val)) {
+        return options.long ? fmtLong(val) : fmtShort(val);
+      }
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse(str) {
+      str = String(str);
+      if (str.length > 100) {
+        return;
+      }
+      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        str
+      );
+      if (!match) {
+        return;
+      }
+      var n = parseFloat(match[1]);
+      var type = (match[2] || "ms").toLowerCase();
+      switch (type) {
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+          return n * y;
+        case "weeks":
+        case "week":
+        case "w":
+          return n * w;
+        case "days":
+        case "day":
+        case "d":
+          return n * d;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+          return n * h;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+          return n * m;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+          return n * s;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+          return n;
+        default:
+          return void 0;
+      }
+    }
+    function fmtShort(ms2) {
+      var msAbs = Math.abs(ms2);
+      if (msAbs >= d) {
+        return Math.round(ms2 / d) + "d";
+      }
+      if (msAbs >= h) {
+        return Math.round(ms2 / h) + "h";
+      }
+      if (msAbs >= m) {
+        return Math.round(ms2 / m) + "m";
+      }
+      if (msAbs >= s) {
+        return Math.round(ms2 / s) + "s";
+      }
+      return ms2 + "ms";
+    }
+    function fmtLong(ms2) {
+      var msAbs = Math.abs(ms2);
+      if (msAbs >= d) {
+        return plural(ms2, msAbs, d, "day");
+      }
+      if (msAbs >= h) {
+        return plural(ms2, msAbs, h, "hour");
+      }
+      if (msAbs >= m) {
+        return plural(ms2, msAbs, m, "minute");
+      }
+      if (msAbs >= s) {
+        return plural(ms2, msAbs, s, "second");
+      }
+      return ms2 + " ms";
+    }
+    function plural(ms2, msAbs, n, name) {
+      var isPlural = msAbs >= n * 1.5;
+      return Math.round(ms2 / n) + " " + name + (isPlural ? "s" : "");
+    }
+    var TELEMETRY_ENDPOINT_URL_PRODUCTION = "https://checkpoint.prisma.io";
+    var childPath = path__default["default"].join(eval("__dirname"), "child");
+    async function check(input) {
+      const defaultCache = getCacheFile(input.product, input.cli_path_hash || "default");
+      const ci = require_ci_info();
+      const endpointUrl = input.endpoint || process.env.PRISMA_TELEMETRY_ENDPOINT || TELEMETRY_ENDPOINT_URL_PRODUCTION;
+      const state = {
+        product: input.product,
+        version: input.version,
+        cli_install_type: input.cli_install_type || "",
+        information: input.information || "",
+        local_timestamp: input.local_timestamp || rfc3339(/* @__PURE__ */ new Date()),
+        project_hash: input.project_hash,
+        cli_path: input.cli_path || "",
+        cli_path_hash: input.cli_path_hash || "",
+        endpoint: endpointUrl,
+        disable: typeof input.disable === "undefined" ? false : input.disable,
+        arch: input.arch || os__default["default"].arch(),
+        os: input.os || os__default["default"].platform(),
+        node_version: input.node_version || process.version,
+        ci: typeof input.ci !== "undefined" ? input.ci : ci.isCI,
+        ci_name: typeof input.ci_name !== "undefined" ? input.ci_name || "" : ci.name || "",
+        command: input.command || "",
+        schema_providers: input.schema_providers || [],
+        schema_preview_features: input.schema_preview_features || [],
+        schema_generators_providers: input.schema_generators_providers || [],
+        cache_file: input.cache_file || defaultCache,
+        cache_duration: typeof input.cache_duration === "undefined" ? ms("12h") : input.cache_duration,
+        remind_duration: typeof input.remind_duration === "undefined" ? ms("48h") : input.remind_duration,
+        force: typeof input.force === "undefined" ? false : input.force,
+        timeout: getTimeout(input.timeout),
+        unref: typeof input.unref === "undefined" ? true : input.unref,
+        child_path: input.child_path || childPath,
+        now: () => Date.now(),
+        client_event_id: input.client_event_id || "",
+        previous_client_event_id: input.previous_client_event_id || "",
+        check_if_update_available: false
+      };
+      if ((process.env["CHECKPOINT_DISABLE"] || state.disable) && !state.force) {
+        return {
+          status: "disabled"
+        };
+      }
+      const config = await Config.new(state);
+      const cacheResponse = await config.checkCache(state);
+      state.check_if_update_available = cacheResponse.stale === true || !cacheResponse.cache;
+      const child = spawn(state);
+      if (state.unref) {
+        child.unref();
+        child.disconnect();
+      }
+      if (cacheResponse.stale === true || !cacheResponse.cache) {
+        return {
+          status: "waiting",
+          data: child
+        };
+      }
+      for (const key of Object.keys(state)) {
+        if (state[key]) {
+          await config.set({
+            [key]: state[key]
+          });
+        }
+      }
+      const userReminded = state.now() - cacheResponse.cache.last_reminder < state.remind_duration;
+      if (userReminded) {
+        return {
+          status: "reminded",
+          data: cacheResponse.cache.output
+        };
+      }
+      await config.set({
+        last_reminder: state.now()
+      });
+      return {
+        status: "ok",
+        data: cacheResponse.cache.output
+      };
+    }
+    function getCacheFile(product, cacheIdentifier) {
+      const dirs = paths(`checkpoint`);
+      return path__default["default"].join(dirs.cache, `${product}-${cacheIdentifier}`);
+    }
+    function getTimeout(inputTimeout) {
+      if (typeof inputTimeout !== "undefined") {
+        return inputTimeout;
+      }
+      const timeoutString = process.env["CHECKPOINT_TIMEOUT"];
+      if (typeof timeoutString === "undefined") {
+        return 5e3;
+      }
+      const timeout = parseInt(timeoutString, 10);
+      if (isNaN(timeout)) {
+        return 5e3;
+      }
+      return timeout;
+    }
+    function getForkOpts(state) {
+      if (state.unref === true) {
+        return {
+          detached: true,
+          // When CHECKPOINT_DEBUG_STDOUT !== undefined, use 'inherit' to let the child print the debug output
+          stdio: process.env.CHECKPOINT_DEBUG_STDOUT ? "inherit" : "ignore",
+          env: process.env
+        };
+      }
+      return { detached: false, stdio: "pipe", env: process.env };
+    }
+    function spawn(state) {
+      return child_process.fork(childPath, [JSON.stringify(state)], getForkOpts(state));
+    }
+    function rfc3339(d2) {
+      function pad(n) {
+        return n < 10 ? "0" + n : n;
+      }
+      function timezoneOffset(offset) {
+        let sign;
+        if (offset === 0) {
+          return "Z";
+        }
+        sign = offset > 0 ? "-" : "+";
+        offset = Math.abs(offset);
+        return sign + pad(Math.floor(offset / 60)) + ":" + pad(offset % 60);
+      }
+      return d2.getFullYear() + "-" + pad(d2.getMonth() + 1) + "-" + pad(d2.getDate()) + "T" + pad(d2.getHours()) + ":" + pad(d2.getMinutes()) + ":" + pad(d2.getSeconds()) + timezoneOffset(d2.getTimezoneOffset());
+    }
+    exports.check = check;
+    exports.getInfo = getInfo;
+    exports.getSignature = getSignature;
+  }
+});
+var require_tmp = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/tmp@0.2.3/node_modules/tmp/lib/tmp.js"(exports2, module2) {
+    "use strict";
+    var fs2 = (0, import_chunk_4VNS5WPM.__require)("fs");
+    var os3 = (0, import_chunk_4VNS5WPM.__require)("os");
+    var path2 = (0, import_chunk_4VNS5WPM.__require)("path");
+    var crypto2 = (0, import_chunk_4VNS5WPM.__require)("crypto");
+    var _c = { fs: fs2.constants, os: os3.constants };
+    var RANDOM_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    var TEMPLATE_PATTERN = /XXXXXX/;
+    var DEFAULT_TRIES = 3;
+    var CREATE_FLAGS = (_c.O_CREAT || _c.fs.O_CREAT) | (_c.O_EXCL || _c.fs.O_EXCL) | (_c.O_RDWR || _c.fs.O_RDWR);
+    var IS_WIN32 = os3.platform() === "win32";
+    var EBADF = _c.EBADF || _c.os.errno.EBADF;
+    var ENOENT = _c.ENOENT || _c.os.errno.ENOENT;
+    var DIR_MODE = 448;
+    var FILE_MODE = 384;
+    var EXIT = "exit";
+    var _removeObjects = [];
+    var FN_RMDIR_SYNC = fs2.rmdirSync.bind(fs2);
+    var _gracefulCleanup = false;
+    function rimraf(dirPath, callback) {
+      return fs2.rm(dirPath, { recursive: true }, callback);
+    }
+    function FN_RIMRAF_SYNC(dirPath) {
+      return fs2.rmSync(dirPath, { recursive: true });
+    }
+    function tmpName(options, callback) {
+      const args = _parseArguments(options, callback), opts = args[0], cb = args[1];
+      try {
+        _assertAndSanitizeOptions(opts);
+      } catch (err) {
+        return cb(err);
+      }
+      let tries = opts.tries;
+      (function _getUniqueName() {
+        try {
+          const name = _generateTmpName(opts);
+          fs2.stat(name, function(err) {
+            if (!err) {
+              if (tries-- > 0) return _getUniqueName();
+              return cb(new Error("Could not get a unique tmp filename, max tries reached " + name));
+            }
+            cb(null, name);
+          });
+        } catch (err) {
+          cb(err);
+        }
+      })();
+    }
+    function tmpNameSync(options) {
+      const args = _parseArguments(options), opts = args[0];
+      _assertAndSanitizeOptions(opts);
+      let tries = opts.tries;
+      do {
+        const name = _generateTmpName(opts);
+        try {
+          fs2.statSync(name);
+        } catch (e) {
+          return name;
+        }
+      } while (tries-- > 0);
+      throw new Error("Could not get a unique tmp filename, max tries reached");
+    }
+    function file(options, callback) {
+      const args = _parseArguments(options, callback), opts = args[0], cb = args[1];
+      tmpName(opts, function _tmpNameCreated(err, name) {
+        if (err) return cb(err);
+        fs2.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd) {
+          if (err2) return cb(err2);
+          if (opts.discardDescriptor) {
+            return fs2.close(fd, function _discardCallback(possibleErr) {
+              return cb(possibleErr, name, void 0, _prepareTmpFileRemoveCallback(name, -1, opts, false));
+            });
+          } else {
+            const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
+            cb(null, name, fd, _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts, false));
+          }
+        });
+      });
+    }
+    function fileSync(options) {
+      const args = _parseArguments(options), opts = args[0];
+      const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
+      const name = tmpNameSync(opts);
+      var fd = fs2.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
+      if (opts.discardDescriptor) {
+        fs2.closeSync(fd);
+        fd = void 0;
+      }
+      return {
+        name,
+        fd,
+        removeCallback: _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts, true)
+      };
+    }
+    function dir(options, callback) {
+      const args = _parseArguments(options, callback), opts = args[0], cb = args[1];
+      tmpName(opts, function _tmpNameCreated(err, name) {
+        if (err) return cb(err);
+        fs2.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err2) {
+          if (err2) return cb(err2);
+          cb(null, name, _prepareTmpDirRemoveCallback(name, opts, false));
+        });
+      });
+    }
+    function dirSync(options) {
+      const args = _parseArguments(options), opts = args[0];
+      const name = tmpNameSync(opts);
+      fs2.mkdirSync(name, opts.mode || DIR_MODE);
+      return {
+        name,
+        removeCallback: _prepareTmpDirRemoveCallback(name, opts, true)
+      };
+    }
+    function _removeFileAsync(fdPath, next) {
+      const _handler = function(err) {
+        if (err && !_isENOENT(err)) {
+          return next(err);
+        }
+        next();
+      };
+      if (0 <= fdPath[0])
+        fs2.close(fdPath[0], function() {
+          fs2.unlink(fdPath[1], _handler);
+        });
+      else fs2.unlink(fdPath[1], _handler);
+    }
+    function _removeFileSync(fdPath) {
+      let rethrownException = null;
+      try {
+        if (0 <= fdPath[0]) fs2.closeSync(fdPath[0]);
+      } catch (e) {
+        if (!_isEBADF(e) && !_isENOENT(e)) throw e;
+      } finally {
+        try {
+          fs2.unlinkSync(fdPath[1]);
+        } catch (e) {
+          if (!_isENOENT(e)) rethrownException = e;
+        }
+      }
+      if (rethrownException !== null) {
+        throw rethrownException;
+      }
+    }
+    function _prepareTmpFileRemoveCallback(name, fd, opts, sync) {
+      const removeCallbackSync = _prepareRemoveCallback(_removeFileSync, [fd, name], sync);
+      const removeCallback = _prepareRemoveCallback(_removeFileAsync, [fd, name], sync, removeCallbackSync);
+      if (!opts.keep) _removeObjects.unshift(removeCallbackSync);
+      return sync ? removeCallbackSync : removeCallback;
+    }
+    function _prepareTmpDirRemoveCallback(name, opts, sync) {
+      const removeFunction = opts.unsafeCleanup ? rimraf : fs2.rmdir.bind(fs2);
+      const removeFunctionSync = opts.unsafeCleanup ? FN_RIMRAF_SYNC : FN_RMDIR_SYNC;
+      const removeCallbackSync = _prepareRemoveCallback(removeFunctionSync, name, sync);
+      const removeCallback = _prepareRemoveCallback(removeFunction, name, sync, removeCallbackSync);
+      if (!opts.keep) _removeObjects.unshift(removeCallbackSync);
+      return sync ? removeCallbackSync : removeCallback;
+    }
+    function _prepareRemoveCallback(removeFunction, fileOrDirName, sync, cleanupCallbackSync) {
+      let called = false;
+      return function _cleanupCallback(next) {
+        if (!called) {
+          const toRemove = cleanupCallbackSync || _cleanupCallback;
+          const index = _removeObjects.indexOf(toRemove);
+          if (index >= 0) _removeObjects.splice(index, 1);
+          called = true;
+          if (sync || removeFunction === FN_RMDIR_SYNC || removeFunction === FN_RIMRAF_SYNC) {
+            return removeFunction(fileOrDirName);
+          } else {
+            return removeFunction(fileOrDirName, next || function() {
+            });
+          }
+        }
+      };
+    }
+    function _garbageCollector() {
+      if (!_gracefulCleanup) return;
+      while (_removeObjects.length) {
+        try {
+          _removeObjects[0]();
+        } catch (e) {
+        }
+      }
+    }
+    function _randomChars(howMany) {
+      let value = [], rnd = null;
+      try {
+        rnd = crypto2.randomBytes(howMany);
+      } catch (e) {
+        rnd = crypto2.pseudoRandomBytes(howMany);
+      }
+      for (var i = 0; i < howMany; i++) {
+        value.push(RANDOM_CHARS[rnd[i] % RANDOM_CHARS.length]);
+      }
+      return value.join("");
+    }
+    function _isBlank(s2) {
+      return s2 === null || _isUndefined(s2) || !s2.trim();
+    }
+    function _isUndefined(obj) {
+      return typeof obj === "undefined";
+    }
+    function _parseArguments(options, callback) {
+      if (typeof options === "function") {
+        return [{}, options];
+      }
+      if (_isUndefined(options)) {
+        return [{}, callback];
+      }
+      const actualOptions = {};
+      for (const key of Object.getOwnPropertyNames(options)) {
+        actualOptions[key] = options[key];
+      }
+      return [actualOptions, callback];
+    }
+    function _generateTmpName(opts) {
+      const tmpDir = opts.tmpdir;
+      if (!_isUndefined(opts.name))
+        return path2.join(tmpDir, opts.dir, opts.name);
+      if (!_isUndefined(opts.template))
+        return path2.join(tmpDir, opts.dir, opts.template).replace(TEMPLATE_PATTERN, _randomChars(6));
+      const name = [
+        opts.prefix ? opts.prefix : "tmp",
+        "-",
+        process.pid,
+        "-",
+        _randomChars(12),
+        opts.postfix ? "-" + opts.postfix : ""
+      ].join("");
+      return path2.join(tmpDir, opts.dir, name);
+    }
+    function _assertAndSanitizeOptions(options) {
+      options.tmpdir = _getTmpDir(options);
+      const tmpDir = options.tmpdir;
+      if (!_isUndefined(options.name))
+        _assertIsRelative(options.name, "name", tmpDir);
+      if (!_isUndefined(options.dir))
+        _assertIsRelative(options.dir, "dir", tmpDir);
+      if (!_isUndefined(options.template)) {
+        _assertIsRelative(options.template, "template", tmpDir);
+        if (!options.template.match(TEMPLATE_PATTERN))
+          throw new Error(`Invalid template, found "${options.template}".`);
+      }
+      if (!_isUndefined(options.tries) && isNaN(options.tries) || options.tries < 0)
+        throw new Error(`Invalid tries, found "${options.tries}".`);
+      options.tries = _isUndefined(options.name) ? options.tries || DEFAULT_TRIES : 1;
+      options.keep = !!options.keep;
+      options.detachDescriptor = !!options.detachDescriptor;
+      options.discardDescriptor = !!options.discardDescriptor;
+      options.unsafeCleanup = !!options.unsafeCleanup;
+      options.dir = _isUndefined(options.dir) ? "" : path2.relative(tmpDir, _resolvePath(options.dir, tmpDir));
+      options.template = _isUndefined(options.template) ? void 0 : path2.relative(tmpDir, _resolvePath(options.template, tmpDir));
+      options.template = _isBlank(options.template) ? void 0 : path2.relative(options.dir, options.template);
+      options.name = _isUndefined(options.name) ? void 0 : options.name;
+      options.prefix = _isUndefined(options.prefix) ? "" : options.prefix;
+      options.postfix = _isUndefined(options.postfix) ? "" : options.postfix;
+    }
+    function _resolvePath(name, tmpDir) {
+      if (name.startsWith(tmpDir)) {
+        return path2.resolve(name);
+      } else {
+        return path2.resolve(path2.join(tmpDir, name));
+      }
+    }
+    function _assertIsRelative(name, option, tmpDir) {
+      if (option === "name") {
+        if (path2.isAbsolute(name))
+          throw new Error(`${option} option must not contain an absolute path, found "${name}".`);
+        let basename = path2.basename(name);
+        if (basename === ".." || basename === "." || basename !== name)
+          throw new Error(`${option} option must not contain a path, found "${name}".`);
+      } else {
+        if (path2.isAbsolute(name) && !name.startsWith(tmpDir)) {
+          throw new Error(`${option} option must be relative to "${tmpDir}", found "${name}".`);
+        }
+        let resolvedPath = _resolvePath(name, tmpDir);
+        if (!resolvedPath.startsWith(tmpDir))
+          throw new Error(`${option} option must be relative to "${tmpDir}", found "${resolvedPath}".`);
+      }
+    }
+    function _isEBADF(error) {
+      return _isExpectedError(error, -EBADF, "EBADF");
+    }
+    function _isENOENT(error) {
+      return _isExpectedError(error, -ENOENT, "ENOENT");
+    }
+    function _isExpectedError(error, errno, code) {
+      return IS_WIN32 ? error.code === code : error.code === code && error.errno === errno;
+    }
+    function setGracefulCleanup() {
+      _gracefulCleanup = true;
+    }
+    function _getTmpDir(options) {
+      return path2.resolve(options && options.tmpdir || os3.tmpdir());
+    }
+    process.addListener(EXIT, _garbageCollector);
+    Object.defineProperty(module2.exports, "tmpdir", {
+      enumerable: true,
+      configurable: false,
+      get: function() {
+        return _getTmpDir();
+      }
+    });
+    module2.exports.dir = dir;
+    module2.exports.dirSync = dirSync;
+    module2.exports.file = file;
+    module2.exports.fileSync = fileSync;
+    module2.exports.tmpName = tmpName;
+    module2.exports.tmpNameSync = tmpNameSync;
+    module2.exports.setGracefulCleanup = setGracefulCleanup;
+  }
+});
+var checkpoint = (0, import_chunk_4VNS5WPM.__toESM)(require_dist());
+var import_strip_ansi = (0, import_chunk_4VNS5WPM.__toESM)((0, import_chunk_ZSINRHD4.require_strip_ansi)());
+var import_tmp = (0, import_chunk_4VNS5WPM.__toESM)(require_tmp());
+import_tmp.default.setGracefulCleanup();
+async function sendPanic({
+  error,
+  cliVersion,
+  enginesVersion,
+  getDatabaseVersionSafe
+}) {
+  let dbVersion;
+  if (error.area === "LIFT_CLI") {
+    const getDatabaseVersionParams = (0, import_chunk_XKZ6CBLA.z)({
+      introspectionUrl: error.introspectionUrl
+    }).with({ introspectionUrl: import_chunk_XKZ6CBLA.N.not(void 0) }, ({ introspectionUrl }) => {
+      return {
+        datasource: {
+          tag: "ConnectionString",
+          url: introspectionUrl
+        }
+      };
+    }).otherwise(() => void 0);
+    dbVersion = await getDatabaseVersionSafe(getDatabaseVersionParams);
+  }
+  const migrateRequest = error.request ? JSON.stringify(
+    (0, import_chunk_KDHESRKE.mapScalarValues)(error.request, (value) => {
+      if (typeof value === "string") {
+        return (0, import_chunk_KDHESRKE.maskSchema)(value);
+      }
+      return value;
+    })
+  ) : void 0;
+  const params = {
+    area: error.area,
+    kind: "RUST_PANIC",
+    cliVersion,
+    binaryVersion: enginesVersion,
+    command: getCommand(),
+    jsStackTrace: (0, import_strip_ansi.default)(error.stack || error.message),
+    rustStackTrace: error.rustStack,
+    operatingSystem: `${import_os.default.arch()} ${import_os.default.platform()} ${import_os.default.release()}`,
+    platform: await (0, import_get_platform.getBinaryTargetForCurrentPlatform)(),
+    liftRequest: migrateRequest,
+    fingerprint: await checkpoint.getSignature(),
+    sqlDump: void 0,
+    dbVersion
+  };
+  const signedUrl = await (0, import_chunk_5AI4FIZ3.createErrorReport)(params);
+  const id = await (0, import_chunk_5AI4FIZ3.makeErrorReportCompleted)(signedUrl);
+  return id;
+}
+function getCommand() {
+  if (process.argv[2] === "introspect") {
+    return "introspect";
+  } else if (process.argv[2] === "db" && process.argv[3] === "pull") {
+    return "db pull";
+  }
+  return process.argv.slice(2).join(" ");
+}
+/*! Bundled license information:
+
+tmp/lib/tmp.js:
+  (*!
+   * Tmp
+   *
+   * Copyright (c) 2011-2017 KARASZI Istvan <github@spam.raszi.hu>
+   *
+   * MIT Licensed
+   *)
+*/