@tushar-br/desktop 1.0.274 → 1.0.276

package/staging_area/desktop/rilvox/node_modules/@prisma/engines/node_modules/@prisma/get-platform/dist/chunk-GGL63BNP.js

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

package/staging_area/desktop/rilvox/node_modules/@prisma/engines/node_modules/@prisma/get-platform/dist/chunk-IPLRRT6O.js

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

package/staging_area/desktop/rilvox/node_modules/@prisma/engines/node_modules/@prisma/get-platform/dist/chunk-M5T7GI2R.js

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