binary-collections 2.0.9 → 2.0.11

package/lib/utils/chatgpt.mjs

@@ -0,0 +1,8 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  runChatGpt
+} from "../chunk-N436BNBK.mjs";
+import "../chunk-QQ4A6DLD.mjs";
+export {
+  runChatGpt
+};

package/lib/utils/findEnvFiles.cjs

@@ -0,0 +1,107 @@
+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);
+
+// src/utils/findEnvFiles.js
+var findEnvFiles_exports = {};
+__export(findEnvFiles_exports, {
+  findEnvFiles: () => findEnvFiles
+});
+module.exports = __toCommonJS(findEnvFiles_exports);
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var glob = __toESM(require("glob"), 1);
+var DEFAULT_IGNORES = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/.yarn/**",
+  "**/.pnpm/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/coverage/**",
+  "**/vendor/**",
+  "**/tmp/**",
+  "**/.cache/**",
+  "**/assets/**",
+  "**/logs/**",
+  "**/output/**",
+  "**/public/**",
+  "**/static/**",
+  "**/temp/**",
+  "**/backup/**",
+  "**/backups/**",
+  "**/examples/**",
+  "**/docs/**",
+  "**/tests/**",
+  "**/__tests__/**",
+  "**/spec/**",
+  "**/__specs__/**",
+  "**/scripts/**",
+  "**/bin/**",
+  "**/hooks/**",
+  "**/config/**",
+  "**/configs/**",
+  "**/settings/**",
+  "**/.vscode/**",
+  "**/.idea/**"
+];
+function findEnvFiles(startDir = process.cwd(), filter) {
+  const found = /* @__PURE__ */ new Set();
+  function addFile(file) {
+    const normalized = import_node_path.default.normalize(file);
+    if (typeof filter === "function" && !filter(normalized)) {
+      return;
+    }
+    found.add(normalized);
+  }
+  let current = import_node_path.default.resolve(startDir);
+  while (true) {
+    const envPath = import_node_path.default.join(current, ".env");
+    if (import_node_fs.default.existsSync(envPath)) {
+      addFile(envPath);
+    }
+    const parent = import_node_path.default.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  const files = glob.globSync("**/.env*", {
+    cwd: startDir,
+    absolute: true,
+    nodir: true,
+    ignore: DEFAULT_IGNORES
+  });
+  for (const file of files) {
+    addFile(file);
+  }
+  return [...found];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findEnvFiles
+});

package/lib/utils/findEnvFiles.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Find .env files.
+ *
+ * @param {string} startDir
+ * @param {(file:string)=>boolean} [filter]
+ * @returns {string[]}
+ */
+export function findEnvFiles(startDir?: string, filter?: (file: string) => boolean): string[];

package/lib/utils/findEnvFiles.js

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findEnvFiles = findEnvFiles;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const glob = __importStar(require("glob"));
+const DEFAULT_IGNORES = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/.yarn/**",
+    "**/.pnpm/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/coverage/**",
+    "**/vendor/**",
+    "**/tmp/**",
+    "**/.cache/**",
+    "**/assets/**",
+    "**/logs/**",
+    "**/output/**",
+    "**/public/**",
+    "**/static/**",
+    "**/temp/**",
+    "**/backup/**",
+    "**/backups/**",
+    "**/examples/**",
+    "**/docs/**",
+    "**/tests/**",
+    "**/__tests__/**",
+    "**/spec/**",
+    "**/__specs__/**",
+    "**/scripts/**",
+    "**/bin/**",
+    "**/hooks/**",
+    "**/config/**",
+    "**/configs/**",
+    "**/settings/**",
+    "**/.vscode/**",
+    "**/.idea/**"
+];
+/**
+ * Find .env files.
+ *
+ * @param {string} startDir
+ * @param {(file:string)=>boolean} [filter]
+ * @returns {string[]}
+ */
+function findEnvFiles(startDir = process.cwd(), filter) {
+    const found = new Set();
+    function addFile(file) {
+        const normalized = node_path_1.default.normalize(file);
+        if (typeof filter === "function" && !filter(normalized)) {
+            return;
+        }
+        found.add(normalized);
+    }
+    /* --------------------------------
+     * Parent directories
+     * -------------------------------- */
+    let current = node_path_1.default.resolve(startDir);
+    while (true) {
+        const envPath = node_path_1.default.join(current, ".env");
+        if (node_fs_1.default.existsSync(envPath)) {
+            addFile(envPath);
+        }
+        const parent = node_path_1.default.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    /* --------------------------------
+     * Subdirectories via glob
+     * -------------------------------- */
+    const files = glob.globSync("**/.env*", {
+        cwd: startDir,
+        absolute: true,
+        nodir: true,
+        ignore: DEFAULT_IGNORES
+    });
+    for (const file of files) {
+        addFile(file);
+    }
+    return [...found];
+}

package/lib/utils/findEnvFiles.mjs

@@ -0,0 +1,8 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  findEnvFiles
+} from "../chunk-ID2WBTE2.mjs";
+import "../chunk-QQ4A6DLD.mjs";
+export {
+  findEnvFiles
+};

package/lib/utils/findWorkspaceRoot.cjs

@@ -0,0 +1,70 @@
+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);
+
+// src/utils/findWorkspaceRoot.js
+var findWorkspaceRoot_exports = {};
+__export(findWorkspaceRoot_exports, {
+  findWorkspaceRoot: () => findYarnWorkspaceRootFS,
+  findWorkspaceRootYC: () => findWorkspaceRootYC,
+  findYarnWorkspaceRootFS: () => findYarnWorkspaceRootFS
+});
+module.exports = __toCommonJS(findWorkspaceRoot_exports);
+var import_core = require("@yarnpkg/core");
+var import_upath = __toESM(require("upath"), 1);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+async function findWorkspaceRootYC(cwd = process.cwd()) {
+  const configuration = await import_core.Configuration.find(cwd, null);
+  const { project } = await import_core.Project.find(configuration, cwd);
+  return project.cwd;
+}
+function findYarnWorkspaceRootFS(cwd = process.cwd()) {
+  let current = import_upath.default.resolve(cwd);
+  while (true) {
+    const pkgPath = import_upath.default.join(current, "package.json");
+    if (import_fs_extra.default.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(import_fs_extra.default.readFileSync(pkgPath, "utf8"));
+        if (pkg.workspaces || import_fs_extra.default.existsSync(import_upath.default.join(current, "yarn.lock")) || import_fs_extra.default.existsSync(import_upath.default.join(current, ".yarn"))) {
+          return current;
+        }
+      } catch {
+      }
+    }
+    const parent = import_upath.default.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findWorkspaceRoot,
+  findWorkspaceRootYC,
+  findYarnWorkspaceRootFS
+});

package/lib/utils/findWorkspaceRoot.d.ts

@@ -0,0 +1,9 @@
+export function findWorkspaceRootYC(cwd?: string): Promise<import("@yarnpkg/fslib").PortablePath>;
+/**
+ * Find Yarn workspace root directory.
+ *
+ * @param {string} cwd
+ * @returns {string|null}
+ */
+export function findYarnWorkspaceRootFS(cwd?: string): string | null;
+export { findYarnWorkspaceRootFS as findWorkspaceRoot };

package/lib/utils/findWorkspaceRoot.js

@@ -0,0 +1,57 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findWorkspaceRootYC = findWorkspaceRootYC;
+exports.findYarnWorkspaceRootFS = findYarnWorkspaceRootFS;
+exports.findWorkspaceRoot = findYarnWorkspaceRootFS;
+const core_1 = require("@yarnpkg/core");
+const upath_1 = __importDefault(require("upath"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+function findWorkspaceRootYC() {
+    return __awaiter(this, arguments, void 0, function* (cwd = process.cwd()) {
+        const configuration = yield core_1.Configuration.find(cwd, null);
+        const { project } = yield core_1.Project.find(configuration, cwd);
+        return project.cwd;
+    });
+}
+/**
+ * Find Yarn workspace root directory.
+ *
+ * @param {string} cwd
+ * @returns {string|null}
+ */
+function findYarnWorkspaceRootFS(cwd = process.cwd()) {
+    let current = upath_1.default.resolve(cwd);
+    while (true) {
+        const pkgPath = upath_1.default.join(current, "package.json");
+        if (fs_extra_1.default.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs_extra_1.default.readFileSync(pkgPath, "utf8"));
+                if (pkg.workspaces ||
+                    fs_extra_1.default.existsSync(upath_1.default.join(current, "yarn.lock")) ||
+                    fs_extra_1.default.existsSync(upath_1.default.join(current, ".yarn"))) {
+                    return current;
+                }
+            }
+            catch (_a) {
+                // ignore invalid package.json
+            }
+        }
+        const parent = upath_1.default.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}

package/lib/utils/findWorkspaceRoot.mjs

@@ -0,0 +1,40 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "../chunk-QQ4A6DLD.mjs";
+
+// src/utils/findWorkspaceRoot.js
+init_esm_shims();
+import { Configuration, Project } from "@yarnpkg/core";
+import path from "upath";
+import fs from "fs-extra";
+async function findWorkspaceRootYC(cwd = process.cwd()) {
+  const configuration = await Configuration.find(cwd, null);
+  const { project } = await Project.find(configuration, cwd);
+  return project.cwd;
+}
+function findYarnWorkspaceRootFS(cwd = process.cwd()) {
+  let current = path.resolve(cwd);
+  while (true) {
+    const pkgPath = path.join(current, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        if (pkg.workspaces || fs.existsSync(path.join(current, "yarn.lock")) || fs.existsSync(path.join(current, ".yarn"))) {
+          return current;
+        }
+      } catch {
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+export {
+  findYarnWorkspaceRootFS as findWorkspaceRoot,
+  findWorkspaceRootYC,
+  findYarnWorkspaceRootFS
+};

package/lib/{utils.cjs → utils/index.cjs}

@@ -1,4 +1,4 @@
-// src/utils.js
+// src/utils/index.cjs
 var fs = require("fs");
 var path = require("upath");
 var argv = require("minimist")(process.argv.slice(2));
@@ -50,31 +50,78 @@ function getArgs() {
 }
 module.exports.getArgs = getArgs;
 function del(fullPath) {
-  if (fs.statSync(fullPath).isDirectory()) {
-    const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
-    for (let i = 0; i < subdir.length; i++) {
-      del(subdir[i]);
+  try {
+    if (!fs.existsSync(fullPath)) return;
+    const stat = fs.lstatSync(fullPath);
+    if (stat.isSymbolicLink()) {
+      try {
+        fs.unlinkSync(fullPath);
+        console.log("deleted symlink", fullPath);
+      } catch (e) {
+        console.log("failed delete symlink", fullPath, e && e.message);
+      }
+      return;
+    }
+    if (stat.isDirectory()) {
+      const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+      for (let i = 0; i < subdir.length; i++) {
+        del(subdir[i]);
+      }
+      try {
+        fs.rmdirSync(fullPath);
+        console.log("deleted", fullPath);
+      } catch (e) {
+        try {
+          fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+          console.log("deleted", fullPath);
+        } catch (ee) {
+          console.log("failed delete", fullPath, ee && ee.message);
+        }
+      }
+      return;
     }
-  } else {
     try {
-      fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+      fs.unlinkSync(fullPath);
       console.log("deleted", fullPath);
-    } catch (_) {
-      console.log("failed delete", fullPath);
+    } catch (e) {
+      try {
+        fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+        console.log("deleted", fullPath);
+      } catch (ee) {
+        console.log("failed delete", fullPath, ee && ee.message);
+      }
     }
+  } catch (err) {
+    console.log("failed delete", fullPath, err && err.message);
   }
 }
 module.exports.del = del;
 function delStream(globStream) {
   globStream.stream().on("data", (result) => {
     const fullPath = path.resolve(process.cwd(), result);
-    if (fs.statSync(fullPath).isDirectory()) {
-      const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
-      for (let i = 0; i < subdir.length; i++) {
-        del(subdir[i]);
+    try {
+      if (fs.existsSync(fullPath)) {
+        const stat = fs.lstatSync(fullPath);
+        if (stat.isSymbolicLink()) {
+          try {
+            fs.unlinkSync(fullPath);
+            console.log("deleted symlink", fullPath);
+          } catch (e) {
+            console.log("failed delete symlink", fullPath, e && e.message);
+          }
+          return;
+        }
+        if (stat.isDirectory()) {
+          const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+          for (let i = 0; i < subdir.length; i++) {
+            del(subdir[i]);
+          }
+        }
       }
+      del(fullPath);
+    } catch (err) {
+      console.log("failed processing", fullPath, err && err.message);
     }
-    del(fullPath);
   });
 }
 module.exports.delStream = delStream;

package/lib/{utils.mjs → utils/index.mjs}

@@ -1,6 +1,6 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_utils
-} from "./chunk-APBWENF6.mjs";
-import "./chunk-AASHBCRW.mjs";
+} from "../chunk-Z6JLYU2J.mjs";
+import "../chunk-QQ4A6DLD.mjs";
 export default require_utils();

package/lib/utils/isGithubTokenValid.cjs

@@ -0,0 +1,64 @@
+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);
+
+// src/utils/isGithubTokenValid.js
+var isGithubTokenValid_exports = {};
+__export(isGithubTokenValid_exports, {
+  isGitHubTokenValid: () => isGitHubTokenValid
+});
+module.exports = __toCommonJS(isGithubTokenValid_exports);
+var import_node_https = __toESM(require("https"), 1);
+async function isGitHubTokenValid(token) {
+  if (!token || typeof token !== "string") {
+    return false;
+  }
+  return new Promise((resolve) => {
+    const req = import_node_https.default.request(
+      {
+        hostname: "api.github.com",
+        path: "/user",
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "User-Agent": "github-token-validator",
+          Accept: "application/vnd.github+json"
+        }
+      },
+      (res) => {
+        resolve(res.statusCode === 200);
+        res.resume();
+      }
+    );
+    req.on("error", () => resolve(false));
+    req.end();
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isGitHubTokenValid
+});

package/lib/utils/isGithubTokenValid.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check whether a GitHub token is valid.
+ *
+ * @param {string} token GitHub personal access token
+ * @returns {Promise<boolean>}
+ */
+export function isGitHubTokenValid(token: string): Promise<boolean>;

package/lib/utils/isGithubTokenValid.js

@@ -0,0 +1,48 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGitHubTokenValid = isGitHubTokenValid;
+const node_https_1 = __importDefault(require("node:https"));
+/**
+ * Check whether a GitHub token is valid.
+ *
+ * @param {string} token GitHub personal access token
+ * @returns {Promise<boolean>}
+ */
+function isGitHubTokenValid(token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!token || typeof token !== "string") {
+            return false;
+        }
+        return new Promise((resolve) => {
+            const req = node_https_1.default.request({
+                hostname: "api.github.com",
+                path: "/user",
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "User-Agent": "github-token-validator",
+                    Accept: "application/vnd.github+json"
+                }
+            }, (res) => {
+                // 200 = valid token
+                resolve(res.statusCode === 200);
+                // consume response to avoid memory leak
+                res.resume();
+            });
+            req.on("error", () => resolve(false));
+            req.end();
+        });
+    });
+}