binary-collections 2.0.12 → 2.0.14

package/lib/chunk-JK3MG2KF.mjs

@@ -0,0 +1,236 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_fetchResponse
+} from "./chunk-KLKAIFKI.mjs";
+import {
+  require_config
+} from "./chunk-SARIXFHP.mjs";
+import {
+  require_utils
+} from "./chunk-6RK5UCTP.mjs";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/package-resolutions-updater.mjs
+init_esm_shims();
+var import_config = __toESM(require_config(), 1);
+var import_fetchResponse = __toESM(require_fetchResponse(), 1);
+var utils = __toESM(require_utils(), 1);
+import fs from "fs";
+import { parseGitHubUrl } from "git-command-helper";
+import os from "os";
+import path from "upath";
+var args = utils.getArgs();
+if (args.help || args.h) {
+  showHelp();
+}
+function showHelp() {
+  const helpText = `
+GitHub Package Resolutions Updater
+Usage:
+  node src/package-resolutions-updater.mjs [options]
+Options:
+  --help, -h           Show this help message
+Description:
+  Updates the commit hashes in package.json's 'resolutions' field for GitHub tarball URLs to point to the latest commit SHA of the corresponding repository and branch.
+Features:
+  - Parses GitHub URLs to extract repository owner, name, and branch.
+  - Fetches the latest commit SHA across all branches using GitHub's API.
+  - Replaces the old branch or commit in the URL with the latest SHA.
+  - Overwrites package.json with the updated URLs.
+Requirements:
+  - GitHub Personal Access Token (GITHUB_TOKEN) via .env
+  - ESM support (type: "module" in package.json)
+  - Node.js v18+ recommended
+Dependencies:
+  - ansi-colors \u2013 for styled terminal output
+Examples:
+  node src/package-resolutions-updater.mjs
+  node src/package-resolutions-updater.mjs --help
+
+`;
+  console.log(helpText);
+  process.exit(0);
+}
+var GITHUB_USER_AGENTS = [
+  "octokit-rest.js/19.0.7",
+  "GitHub CLI/2.40.0",
+  "Mozilla/5.0 (compatible; GitHubCopilot/1.0)",
+  "PostmanRuntime/7.32.3",
+  "binary-collections-resolver/1.0 (+https://github.com/dimaslanjaka/bin)"
+];
+var userAgentDir = path.join(os.tmpdir(), "nodejs");
+var userAgentFile = path.join(userAgentDir, "useragent.txt");
+var selectedUserAgent;
+try {
+  if (!fs.existsSync(userAgentDir)) fs.mkdirSync(userAgentDir, { recursive: true });
+  if (fs.existsSync(userAgentFile)) {
+    const fileAgent = fs.readFileSync(userAgentFile, "utf-8").trim();
+    if (GITHUB_USER_AGENTS.includes(fileAgent)) {
+      selectedUserAgent = fileAgent;
+    }
+  }
+  if (!selectedUserAgent) {
+    selectedUserAgent = GITHUB_USER_AGENTS[Math.floor(Math.random() * GITHUB_USER_AGENTS.length)];
+    fs.writeFileSync(userAgentFile, selectedUserAgent, "utf-8");
+  }
+} catch (_e) {
+  selectedUserAgent = GITHUB_USER_AGENTS[Math.floor(Math.random() * GITHUB_USER_AGENTS.length)];
+}
+async function fetchJson(url) {
+  var _a;
+  const response = await (0, import_fetchResponse.default)(url, {
+    headers: {
+      "User-Agent": selectedUserAgent,
+      Accept: "application/vnd.github.v3+json",
+      "X-GitHub-Api-Version": "2022-11-28",
+      ...import_config.GITHUB_ACCESS_TOKEN ? { Authorization: `token ${import_config.GITHUB_ACCESS_TOKEN}` } : {}
+    },
+    responseType: "json"
+  });
+  if (response.status < 200 || response.status >= 300) {
+    const message = ((_a = response.data) == null ? void 0 : _a.message) || "Unknown error";
+    throw new Error(`GitHub API Error ${response.status}: ${message}
+URL: ${url}`);
+  }
+  return response.data;
+}
+async function getLatestCommit(owner, repo, branch = "main") {
+  var _a, _b, _c, _d;
+  const url = `https://api.github.com/repos/${owner}/${repo}/commits/${branch}`;
+  const json = await fetchJson(url);
+  const sha = json.sha;
+  const dateStr = ((_b = (_a = json.commit) == null ? void 0 : _a.committer) == null ? void 0 : _b.date) || ((_d = (_c = json.commit) == null ? void 0 : _c.author) == null ? void 0 : _d.date);
+  if (!sha || !dateStr) {
+    console.log(json);
+    throw new Error(`Missing SHA or date for ${owner}/${repo}@${branch}`);
+  }
+  return {
+    owner,
+    repo,
+    branch,
+    sha,
+    date: new Date(dateStr).toISOString()
+  };
+}
+async function getLatestCommitAcrossBranches(owner, repo) {
+  const branches = await fetchJson(`https://api.github.com/repos/${owner}/${repo}/branches`);
+  const commits = await Promise.all(
+    branches.map(async ({ name, commit }) => {
+      var _a, _b, _c, _d;
+      const commitSha = commit == null ? void 0 : commit.sha;
+      if (!commitSha) {
+        console.warn(`No commit SHA for '${owner}/${repo}' branch: ${name}`);
+        return { branch: name, sha: "", date: /* @__PURE__ */ new Date(0) };
+      }
+      try {
+        const commitData = await fetchJson(`https://api.github.com/repos/${owner}/${repo}/commits/${commitSha}`);
+        const dateStr = ((_b = (_a = commitData.commit) == null ? void 0 : _a.committer) == null ? void 0 : _b.date) || ((_d = (_c = commitData.commit) == null ? void 0 : _c.author) == null ? void 0 : _d.date);
+        const date = dateStr ? new Date(dateStr) : /* @__PURE__ */ new Date(0);
+        return { branch: name, sha: commitData.sha, date };
+      } catch (e) {
+        console.warn(`Failed to fetch commit for ${name}: ${e.message}`);
+        return { branch: name, sha: commitSha, date: /* @__PURE__ */ new Date(0) };
+      }
+    })
+  );
+  const latest = commits.reduce((a, b) => a.date > b.date ? a : b, { date: /* @__PURE__ */ new Date(0) });
+  return {
+    owner,
+    repo,
+    branch: latest.branch,
+    sha: latest.sha,
+    date: latest.date.toISOString()
+  };
+}
+function replaceRawWithLatestHash(url, latestHash) {
+  const parsed = parseGitHubUrl(url);
+  if (!parsed || !parsed.owner || !parsed.repo || !parsed.branch) {
+    throw new Error("Invalid GitHub raw URL");
+  }
+  const branchPrefix = `${parsed.branch}/`;
+  const rawPrefix = parsed.host === "github.com" ? `raw/${branchPrefix}` : branchPrefix;
+  const refsPrefix = `refs/heads/${branchPrefix}`;
+  const path2 = parsed.path.startsWith(rawPrefix) ? parsed.path.slice(rawPrefix.length) : parsed.path.startsWith(refsPrefix) ? parsed.path.slice(refsPrefix.length) : parsed.path.startsWith(branchPrefix) ? parsed.path.slice(branchPrefix.length) : parsed.path;
+  if (parsed.host === "github.com") {
+    return `https://github.com/${parsed.owner}/${parsed.repo}/raw/${latestHash}/${path2}`;
+  }
+  if (parsed.host === "raw.githubusercontent.com") {
+    return `https://raw.githubusercontent.com/${parsed.owner}/${parsed.repo}/${latestHash}/${path2}`;
+  }
+  throw new Error("Invalid GitHub raw URL");
+}
+async function resolvePackageResolutionUpdates(resolutions, specialPackageOverrides = []) {
+  const updates = [];
+  for (const [currentPkgName, version] of Object.entries(resolutions || {})) {
+    const isUrl = typeof version === "string" && (version.startsWith("http://") || version.startsWith("https://"));
+    if (!isUrl) {
+      updates.push({
+        skipped: true,
+        currentPkgName,
+        url: version,
+        error: new Error("Version is not a URL, skipping")
+      });
+      continue;
+    }
+    let repo;
+    try {
+      repo = parseGitHubUrl(version);
+    } catch (error) {
+      updates.push({
+        skipped: true,
+        currentPkgName,
+        url: version,
+        error
+      });
+      continue;
+    }
+    try {
+      const override = specialPackageOverrides.find((p) => p.pkg === currentPkgName);
+      const latest = override ? await getLatestCommit(override.owner, override.repo, override.branch) : await getLatestCommitAcrossBranches(repo.owner, repo.repo);
+      const new_url = replaceRawWithLatestHash(version, latest.sha);
+      const response = await (0, import_fetchResponse.default)(new_url);
+      if (response.status < 200 || response.status >= 300) {
+        updates.push({
+          failed: true,
+          currentPkgName,
+          url: version,
+          new_url,
+          repo,
+          latest,
+          error: new Error(`New URL not accessible (status ${response.status}).
+original: ${version}
+new: ${new_url}`)
+        });
+        continue;
+      }
+      updates.push({
+        currentPkgName,
+        url: version,
+        new_url,
+        repo,
+        latest
+      });
+    } catch (error) {
+      updates.push({
+        failed: true,
+        currentPkgName,
+        url: version,
+        repo,
+        error
+      });
+    }
+  }
+  return updates;
+}
+
+export {
+  parseGitHubUrl,
+  fetchJson,
+  getLatestCommit,
+  getLatestCommitAcrossBranches,
+  replaceRawWithLatestHash,
+  resolvePackageResolutionUpdates
+};

package/lib/chunk-JMUFQSPE.mjs

@@ -0,0 +1,184 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_config
+} from "./chunk-SWUAEY4H.mjs";
+import {
+  require_utils
+} from "./chunk-6RK5UCTP.mjs";
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/github-workflows/clean-github-actions-caches.cjs
+var require_clean_github_actions_caches = __commonJS({
+  "src/github-workflows/clean-github-actions-caches.cjs"(exports, module) {
+    init_esm_shims();
+    var axios = __require("axios");
+    var { getArgs } = require_utils();
+    var { GITHUB_ACCESS_TOKEN: ACCESS_TOKEN } = require_config();
+    if (!ACCESS_TOKEN) {
+      throw new Error(
+        "Access token is not provided. Please set ACCESS_TOKEN or GITHUB_TOKEN in your environment variables."
+      );
+    }
+    function printHelp() {
+      console.log(`
+GitHub Actions Cache Cleaner
+
+Description:
+  Removes outdated GitHub Actions caches for a repository, keeping only the newest
+  cache for each cache-key prefix. Authenticates via ACCESS_TOKEN or GITHUB_TOKEN
+  from your environment or .env file.
+
+Usage:
+  clean-github-actions-caches [options]
+
+Options:
+  -h, --help           Show this help message
+  -r, --repo <repo>    GitHub repository (owner/repo). If omitted, the tool will
+                       attempt to infer the repository from the current working
+                       directory's git remotes.
+    -p, --prefix-depth <n>
+                         Number of leading cache key segments to use as the
+                         grouping prefix when splitting on /[-_]/. Default: 3.
+
+Environment Variables:
+  ACCESS_TOKEN         GitHub access token (preferred)
+  GITHUB_TOKEN         GitHub access token (fallback)
+
+Behavior & Safety:
+  - Groups caches by a derived prefix from the cache key and keeps the most
+    recently created cache for each group.
+  - Deletes only caches older than the latest per prefix to reduce risk of
+    removing needed artifacts.
+
+Examples:
+  # Run against a specific repo (owner/repo)
+  clean-github-actions-caches --repo octocat/hello-world
+
+  # Run via npx without installing
+    npx --legacy-peer-deps -y binary-collections@https://raw.githubusercontent.com/dimaslanjaka/bin/master/releases/bin.tgz clean-github-actions-caches --repo owner/repo --prefix-depth 3
+
+  # Run via yarn dlx
+    yarn dlx binary-collections@https://raw.githubusercontent.com/dimaslanjaka/bin/master/releases/bin.tgz clean-github-actions-caches --prefix-depth 3
+
+Notes:
+  - Ensure ACCESS_TOKEN or GITHUB_TOKEN is set and has permissions to manage Actions caches.
+  - Intended for repository maintainers with appropriate permissions.
+`);
+    }
+    var argv = getArgs({
+      alias: {
+        h: "help",
+        p: "prefix-depth",
+        r: "repo"
+      },
+      string: ["prefix-depth", "repo"],
+      boolean: ["help"]
+    });
+    if (argv.help) {
+      printHelp();
+      process.exit(0);
+    }
+    function deleteGitHubActionsCache(GH_REPO, cacheId) {
+      return new Promise((resolve, reject) => {
+        const url = `https://api.github.com/repos/${GH_REPO}/actions/caches/${cacheId}`;
+        const token = ACCESS_TOKEN;
+        if (!token) {
+          return reject(new Error("Access token is not provided"));
+        }
+        axios.delete(url, {
+          headers: {
+            Authorization: `token ${token}`,
+            Accept: "application/vnd.github.v3+json"
+          }
+        }).then((response) => {
+          console.log(`Cache (${cacheId}) deleted successfully`, response.data);
+          resolve(response.data);
+        }).catch((error) => {
+          var _a;
+          console.error("Error deleting cache:", ((_a = error.response) == null ? void 0 : _a.data) || error.message || "Unknown error");
+          reject(error);
+        });
+      });
+    }
+    function normalizePrefixDepth(prefixDepth) {
+      const parsed = Number(prefixDepth);
+      if (!Number.isFinite(parsed) || parsed < 1) {
+        return 3;
+      }
+      return Math.floor(parsed);
+    }
+    function isChecksumSegment(segment) {
+      return /^[a-f0-9]{32,}$/i.test(segment);
+    }
+    function getMeaningfulCacheKeyParts(key) {
+      return String(key).split(/[-_]/).filter(Boolean).filter((segment) => !isChecksumSegment(segment));
+    }
+    function getCachePrefix(key, prefixDepth = 3) {
+      const normalizedDepth = normalizePrefixDepth(prefixDepth);
+      const parts = String(key).split(/[-_]/).filter(Boolean);
+      const meaningfulParts = getMeaningfulCacheKeyParts(key);
+      if (meaningfulParts.length !== parts.length) {
+        if (meaningfulParts.length < normalizedDepth) {
+          return `${meaningfulParts.join("-")}-`;
+        }
+        return meaningfulParts.join("-");
+      }
+      if (parts.length <= normalizedDepth) {
+        return parts.join("-");
+      }
+      return parts.slice(0, normalizedDepth).join("-");
+    }
+    function groupCachesByPrefix(caches, prefixDepth = 3) {
+      return caches.reduce(
+        /**
+         * @param {Record<string, Record<string, any>[]>} acc
+         * @param {Record<string, any>} item
+         * @returns {Record<string, Record<string, any>[]>}
+         */
+        (acc, item) => {
+          const prefix = getCachePrefix(item.key, prefixDepth);
+          if (!acc[prefix]) {
+            acc[prefix] = [];
+          }
+          acc[prefix].push(item);
+          return acc;
+        },
+        {}
+      );
+    }
+    function get_caches(GH_REPO, prefixDepth = 3) {
+      const url = `https://api.github.com/repos/${GH_REPO}/actions/caches`;
+      return new Promise((resolve, reject) => {
+        axios.get(url, {
+          headers: {
+            Accept: "application/vnd.github.v3+json",
+            Authorization: `token ${ACCESS_TOKEN}`
+          }
+        }).then((response) => {
+          const data = response.data.actions_caches;
+          const grouped = groupCachesByPrefix(data, prefixDepth);
+          resolve(grouped);
+        }).catch((error) => {
+          reject(error);
+        });
+      });
+    }
+    module.exports = {
+      deleteGitHubActionsCache,
+      getCachePrefix,
+      getMeaningfulCacheKeyParts,
+      get_caches,
+      groupCachesByPrefix,
+      isChecksumSegment,
+      normalizePrefixDepth
+    };
+  }
+});
+
+export {
+  require_clean_github_actions_caches
+};

package/lib/chunk-JVMLKHD2.mjs

@@ -0,0 +1,62 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_config
+} from "./chunk-SARIXFHP.mjs";
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/submodule-remove.cjs
+var require_submodule_remove = __commonJS({
+  "src/submodule-remove.cjs"(exports, module) {
+    init_esm_shims();
+    var { spawnAsync } = __require("cross-spawn");
+    var path = __require("upath");
+    var fs = __require("fs-extra");
+    var { loadDotenv } = require_config();
+    loadDotenv();
+    async function removeSubmodule(submodulePath) {
+      try {
+        await spawnAsync("git", ["submodule", "deinit", "-f", submodulePath], { stdio: "inherit" });
+      } catch (error) {
+        console.warn(`Warning: Could not deinitialize submodule "${submodulePath}". It may not exist.`);
+        console.warn(error.message);
+      }
+      try {
+        await spawnAsync("git", ["config", "--remove-section", `submodule.${submodulePath}`], { stdio: "inherit" });
+      } catch (error) {
+        console.warn(`Warning: Could not remove git config section for submodule "${submodulePath}". It may not exist.`);
+        console.warn(error.message);
+      }
+      const gitModulesPath = path.resolve(".git", "modules", submodulePath);
+      if (fs.existsSync(gitModulesPath)) {
+        fs.rmSync(gitModulesPath, { recursive: true, force: true });
+        console.log(`Removed .git/modules entry for submodule "${submodulePath}".`);
+      } else {
+        console.warn(`Warning: The path "${gitModulesPath}" does not exist. Skipping removal of .git/modules entry.`);
+      }
+      const gitmodulesPath = path.resolve(".gitmodules");
+      if (fs.existsSync(gitmodulesPath)) {
+        let gitmodulesContent = fs.readFileSync(gitmodulesPath, "utf-8");
+        const submoduleSectionRegex = new RegExp(
+          `\\[submodule "${submodulePath.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")}"]([\\s\\S]*?)(?=\\[|$)`,
+          "g"
+        );
+        gitmodulesContent = gitmodulesContent.replace(submoduleSectionRegex, "").trim();
+        fs.writeFileSync(gitmodulesPath, gitmodulesContent);
+        console.log(`Removed submodule "${submodulePath}" from .gitmodules.`);
+      } else {
+        console.warn(`Warning: The .gitmodules file does not exist. Skipping removal of submodule "${submodulePath}".`);
+      }
+      fs.rmSync(path.resolve(submodulePath), { recursive: true, force: true });
+      console.log(`Submodule "${submodulePath}" has been removed.`);
+    }
+    module.exports = removeSubmodule;
+  }
+});
+
+export {
+  require_submodule_remove
+};

package/lib/chunk-KAT2JNLZ.mjs

@@ -0,0 +1,146 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_config
+} from "./chunk-SARIXFHP.mjs";
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/github-workflows/utils.cjs
+var require_utils = __commonJS({
+  "src/github-workflows/utils.cjs"(exports, module) {
+    init_esm_shims();
+    var axios = __require("axios");
+    var { spawn } = __require("cross-spawn");
+    var { GITHUB_ACCESS_TOKEN: TOKEN } = require_config();
+    if (!TOKEN) {
+      console.error("Missing env var: ACCESS_TOKEN or GITHUB_TOKEN");
+      process.exit(1);
+    }
+    var BASE = "https://api.github.com";
+    var HEADERS = {
+      Authorization: `Bearer ${TOKEN}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28"
+    };
+    async function request(url) {
+      try {
+        const res = await axios.get(url, { headers: HEADERS });
+        return res.data;
+      } catch (err) {
+        if (err == null ? void 0 : err.response) {
+          const statusText = err.response.statusText || "Request failed";
+          const responseText = typeof err.response.data === "string" ? err.response.data : JSON.stringify(err.response.data);
+          throw new Error(`${err.response.status} ${statusText}
+${responseText}`);
+        }
+        throw err;
+      }
+    }
+    function runGit(args) {
+      return new Promise((resolve, reject) => {
+        var _a, _b;
+        const child = spawn("git", args, {
+          cwd: process.cwd(),
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        (_a = child.stdout) == null ? void 0 : _a.on("data", (chunk) => {
+          stdout += chunk.toString();
+        });
+        (_b = child.stderr) == null ? void 0 : _b.on("data", (chunk) => {
+          stderr += chunk.toString();
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+          if (code === 0) return resolve(stdout.trim());
+          reject(new Error(stderr.trim() || `git ${args.join(" ")} exited with code ${code}`));
+        });
+      });
+    }
+    function parseOwnerFromUrl(remoteUrl) {
+      const normalized = remoteUrl.trim().replace(/\.git$/i, "");
+      const match = normalized.match(/github\.com[:/](?<owner>[^/]+)\/(?<repo>[^/]+)$/i);
+      return (match == null ? void 0 : match.groups) || null;
+    }
+    function getOwnerFromRemoteUrl(remoteUrl) {
+      const parsed = parseOwnerFromUrl(remoteUrl);
+      return (parsed == null ? void 0 : parsed.owner) || null;
+    }
+    function getRepoFromRemoteUrl(remoteUrl) {
+      const parsed = parseOwnerFromUrl(remoteUrl);
+      return (parsed == null ? void 0 : parsed.repo) || null;
+    }
+    async function getCurrentOwner() {
+      const commands = [
+        ["config", "--local", "--get", "remote.origin.url"],
+        ["remote", "get-url", "origin"]
+      ];
+      for (const args of commands) {
+        try {
+          const remoteUrl = await runGit(args);
+          const owner = getOwnerFromRemoteUrl(remoteUrl);
+          if (owner) return owner;
+        } catch {
+        }
+      }
+      throw new Error("Unable to determine repository owner from git remote.origin.url");
+    }
+    async function getCurrentRepo() {
+      const commands = [
+        ["config", "--local", "--get", "remote.origin.url"],
+        ["remote", "get-url", "origin"]
+      ];
+      for (const args of commands) {
+        try {
+          const remoteUrl = await runGit(args);
+          const repo = getRepoFromRemoteUrl(remoteUrl);
+          if (repo) return repo;
+        } catch {
+        }
+      }
+      throw new Error("Unable to determine repository name from git remote.origin.url");
+    }
+    async function getOwnerRepo() {
+      const owner = await getCurrentOwner();
+      const repo = await getCurrentRepo();
+      return { owner, repo };
+    }
+    async function getLatestRun(owner, repo, workflowId) {
+      var _a;
+      let url;
+      if (workflowId) {
+        url = `${BASE}/repos/${owner}/${repo}/actions/workflows/${encodeURIComponent(workflowId)}/runs?per_page=1`;
+      } else {
+        url = `${BASE}/repos/${owner}/${repo}/actions/runs?per_page=1`;
+      }
+      const data = await request(url);
+      return (_a = data.workflow_runs) == null ? void 0 : _a[0];
+    }
+    async function getJobs(owner, repo, runId) {
+      const data = await request(`${BASE}/repos/${owner}/${repo}/actions/runs/${runId}/jobs`);
+      return data.jobs || [];
+    }
+    module.exports = {
+      BASE,
+      HEADERS,
+      request,
+      runGit,
+      parseOwnerFromUrl,
+      getOwnerFromRemoteUrl,
+      getRepoFromRemoteUrl,
+      getCurrentOwner,
+      getCurrentRepo,
+      getOwnerRepo,
+      getLatestRun,
+      getJobs
+    };
+  }
+});
+
+export {
+  require_utils
+};

package/lib/chunk-KLKAIFKI.mjs

@@ -0,0 +1,40 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/utils/fetchResponse.cjs
+var require_fetchResponse = __commonJS({
+  "src/utils/fetchResponse.cjs"(exports, module) {
+    init_esm_shims();
+    var axios = __require("axios");
+    async function fetchResponse(url, options = {}) {
+      var _a, _b, _c;
+      const response = await axios.get(url, {
+        maxRedirects: 5,
+        responseType: "arraybuffer",
+        validateStatus: () => true,
+        ...options
+      });
+      const finalUrl = ((_b = (_a = response.request) == null ? void 0 : _a.res) == null ? void 0 : _b.responseUrl) ?? ((_c = response.request) == null ? void 0 : _c.responseURL) ?? url;
+      return {
+        finalUrl,
+        status: response.status,
+        statusText: response.statusText,
+        contentType: response.headers["content-type"],
+        contentLength: response.headers["content-length"],
+        dataLength: Buffer.isBuffer(response.data) ? response.data.length : void 0,
+        data: response.data
+      };
+    }
+    module.exports = fetchResponse;
+    module.exports.fetchResponse = fetchResponse;
+    module.exports.default = fetchResponse;
+  }
+});
+
+export {
+  require_fetchResponse
+};