@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/github/token.js

@@ -1,55 +1,103 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"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 token_exports = {};
-__export(token_exports, {
-  getGitHubToken: () => getGitHubToken,
-  getGitHubTokenFromGitConfig: () => getGitHubTokenFromGitConfig,
-  getGitHubTokenWithFallback: () => getGitHubTokenWithFallback
-});
-module.exports = __toCommonJS(token_exports);
-var import_github = require("../env/github");
-var import_socket_cli = require("../env/socket-cli");
-var import_child = require("../process/spawn/child");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_process_spawn_child = require('../process/spawn/child.js');
+const require_env_github = require('../env/github.js');
+const require_env_socket_cli = require('../env/socket-cli.js');
+
+//#region src/github/token.ts
+/**
+* @file GitHub token resolution. Three sources, in priority order: environment
+*   variables, then `git config github.token`. The combined fallback
+*   (`getGitHubTokenWithFallback`) is what most callers want; the individual
+*   helpers exist so callers can constrain the search (e.g., env-only contexts
+*   where shelling out to git would be wrong).
+*/
+/**
+* Get GitHub authentication token from environment variables. Checks multiple
+* environment variable names in priority order.
+*
+* Environment variables checked (in order):
+*
+* 1. `GITHUB_TOKEN` - Standard GitHub token variable
+* 2. `GH_TOKEN` - Alternative GitHub CLI token variable
+* 3. `SOCKET_CLI_GITHUB_TOKEN` - Socket-specific token variable
+*
+* @example
+*   ;```ts
+*   const token = getGitHubToken()
+*   if (!token) {
+*     console.warn('No GitHub token found')
+*   }
+*   ```
+*
+* @returns The first available GitHub token, or `undefined` if none found
+*/
 function getGitHubToken() {
-  return (0, import_github.getGithubToken)() || (0, import_github.getGhToken)() || (0, import_socket_cli.getSocketCliGithubToken)() || void 0;
+	return /* @__PURE__ */ require_env_github.getGithubToken() || /* @__PURE__ */ require_env_github.getGhToken() || /* @__PURE__ */ require_env_socket_cli.getSocketCliGithubToken() || void 0;
 }
+/**
+* Get GitHub authentication token from git config. Reads the `github.token`
+* configuration value from git config. This is a fallback method when
+* environment variables don't contain a token.
+*
+* @example
+*   ;```ts
+*   const token = await getGitHubTokenFromGitConfig()
+*   if (token) {
+*     console.log('Found token in git config')
+*   }
+*   ```
+*
+* @example
+*   ;```ts
+*   // With custom working directory
+*   const token = await getGitHubTokenFromGitConfig({
+*     cwd: '/path/to/repo',
+*   })
+*   ```
+*
+* @param options - Spawn options for git command execution.
+*
+* @returns GitHub token from git config, or `undefined` if not configured
+*/
 async function getGitHubTokenFromGitConfig(options) {
-  try {
-    const result = await (0, import_child.spawn)("git", ["config", "github.token"], {
-      ...options,
-      stdio: "pipe"
-    });
-    if (result.code === 0 && result.stdout) {
-      return result.stdout.toString().trim();
-    }
-  } catch {
-  }
-  return void 0;
+	/* c8 ignore start - External git process call */
+	try {
+		const result = await require_process_spawn_child.spawn("git", ["config", "github.token"], {
+			...options,
+			stdio: "pipe"
+		});
+		if (result.code === 0 && result.stdout) return result.stdout.toString().trim();
+	} catch {}
+	/* c8 ignore stop */
 }
+/**
+* Get GitHub authentication token from all available sources. Checks
+* environment variables first, then falls back to git config. This is the
+* recommended way to get a GitHub token with maximum compatibility.
+*
+* Priority order:
+*
+* 1. Environment variables (GITHUB_TOKEN, GH_TOKEN, SOCKET_CLI_GITHUB_TOKEN)
+* 2. Git config (github.token)
+*
+* @example
+*   ;```ts
+*   const token = await getGitHubTokenWithFallback()
+*   if (!token) {
+*     throw new ErrorCtor('GitHub token required')
+*   }
+*   ```
+*
+* @returns GitHub token from first available source, or `undefined` if none
+*   found.
+*/
 async function getGitHubTokenWithFallback() {
-  return getGitHubToken() || await getGitHubTokenFromGitConfig();
+	return getGitHubToken() || await getGitHubTokenFromGitConfig();
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getGitHubToken,
-  getGitHubTokenFromGitConfig,
-  getGitHubTokenWithFallback
-});
+
+//#endregion
+exports.getGitHubToken = getGitHubToken;
+exports.getGitHubTokenFromGitConfig = getGitHubTokenFromGitConfig;
+exports.getGitHubTokenWithFallback = getGitHubTokenWithFallback;

package/dist/github/types.js

@@ -1,18 +1,2 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 types_exports = {};
-module.exports = __toCommonJS(types_exports);
+/* Socket Lib - Built with rolldown */

package/dist/globs/_internal.js

@@ -1,96 +1,87 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"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 internal_exports = {};
-__export(internal_exports, {
-  MATCHER_CACHE_MAX_SIZE: () => MATCHER_CACHE_MAX_SIZE,
-  defaultIgnore: () => import_defaults.defaultIgnore,
-  getFastGlob: () => getFastGlob,
-  getFs: () => import_fs.getNodeFs,
-  getFsPromises: () => import_fs_promises.getNodeFsPromises,
-  getPicomatch: () => getPicomatch,
-  matcherCache: () => matcherCache,
-  normalizeGlobResults: () => normalizeGlobResults,
-  normalizeIgnorePatterns: () => normalizeIgnorePatterns,
-  stripTrailingSlash: () => stripTrailingSlash
-});
-module.exports = __toCommonJS(internal_exports);
-var import_array = require("../primordials/array");
-var import_map_set = require("../primordials/map-set");
-var import_string = require("../primordials/string");
-var import_normalize = require("../paths/normalize");
-var import_defaults = require("./defaults");
-var import_fs = require("../node/fs");
-var import_fs_promises = require("../node/fs-promises");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_string = require('../primordials/string.js');
+const require_paths_normalize = require('../paths/normalize.js');
+const require_primordials_array = require('../primordials/array.js');
+const require_primordials_map_set = require('../primordials/map-set.js');
+const require_node_fs = require('../node/fs.js');
+const require_globs_defaults = require('./defaults.js');
+const require_node_fs_promises = require('../node/fs-promises.js');
+
+//#region src/globs/_internal.ts
+/**
+* @file Private internals for `globs/*` modules — lazy module accessors,
+*   normalization helpers, and the matcher LRU cache. The `defaultIgnore` list
+*   lives in the public `defaults.ts` file; this file re-exports it so
+*   co-located helpers can import everything through one path.
+*/
 const MATCHER_CACHE_MAX_SIZE = 100;
-const matcherCache = new import_map_set.MapCtor();
+const matcherCache = new require_primordials_map_set.MapCtor();
 let _fastGlob;
 let _picomatch;
-// @__NO_SIDE_EFFECTS__
+/* @__NO_SIDE_EFFECTS__ */
 function getFastGlob() {
-  if (_fastGlob === void 0) {
-    _fastGlob = require("../external/fast-glob.js");
-  }
-  return _fastGlob;
+	if (_fastGlob === void 0) _fastGlob = /* @__PURE__ */ require("../external/fast-glob.js");
+	return _fastGlob;
 }
-// @__NO_SIDE_EFFECTS__
+/* @__NO_SIDE_EFFECTS__ */
 function getPicomatch() {
-  if (_picomatch === void 0) {
-    _picomatch = require("../external/picomatch.js");
-  }
-  return _picomatch;
+	if (_picomatch === void 0) _picomatch = /* @__PURE__ */ require("../external/picomatch.js");
+	return _picomatch;
 }
+/**
+* Glob results are normalized to forward slashes regardless of the backend
+* (node:fs.glob returns native-OS separators on Windows; fast-glob already
+* returns forward slashes). Single contract: callers don't have to think about
+* separators per platform. Routes through `paths/normalize.normalizePath` so
+* this stays consistent with every other path-shaped string in the lib.
+*/
 function normalizeGlobResults(out) {
-  for (let i = 0; i < out.length; i += 1) {
-    out[i] = (0, import_normalize.normalizePath)(out[i]);
-  }
-  return out;
+	for (let i = 0; i < out.length; i += 1) out[i] = /* @__PURE__ */ require_paths_normalize.normalizePath(out[i]);
+	return out;
 }
+/**
+* Normalize a user-provided ignore array by running every entry through
+* stripTrailingSlash. Returns undefined when `ignore` is not an array so
+* callers can skip merging the option entirely.
+*
+* Uses a pre-sized for-loop instead of `.map`: socket-lib uses primordials (the
+* prototype `Array.prototype.map` can be intercepted or replaced by user code
+* at module load), and a hand-rolled loop is also marginally faster — no
+* callback indirection, no growth of the result array.
+*/
 function normalizeIgnorePatterns(ignore) {
-  if (!(0, import_array.ArrayIsArray)(ignore)) {
-    return void 0;
-  }
-  const source = ignore;
-  const { length } = source;
-  const normalized = new import_array.ArrayCtor(length);
-  for (let i = 0; i < length; i++) {
-    normalized[i] = stripTrailingSlash(source[i]);
-  }
-  return normalized;
+	if (!require_primordials_array.ArrayIsArray(ignore)) return;
+	const source = ignore;
+	const { length } = source;
+	const normalized = new require_primordials_array.ArrayCtor(length);
+	for (let i = 0; i < length; i++) normalized[i] = stripTrailingSlash(source[i]);
+	return normalized;
 }
+/**
+* Strip a trailing `/` from a glob pattern so fast-glob's deep filter matches
+* it. See header comment in `glob.ts` for the full rationale — shortest
+* summary: a `dist/` ignore pattern lets fast-glob walk the whole subtree
+* before filtering, while `dist` (no slash) skips the walk entirely.
+*
+* CharCode 47 is `/`. Reading it that way avoids a per-call string allocation
+* for the literal — primordials-friendly, no behavior change vs.
+* `pattern.endsWith('/')`.
+*/
 function stripTrailingSlash(pattern) {
-  if (pattern.length > 1 && (0, import_string.StringPrototypeCharCodeAt)(pattern, pattern.length - 1) === 47) {
-    return pattern.slice(0, -1);
-  }
-  return pattern;
+	if (pattern.length > 1 && require_primordials_string.StringPrototypeCharCodeAt(pattern, pattern.length - 1) === 47) return pattern.slice(0, -1);
+	return pattern;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  MATCHER_CACHE_MAX_SIZE,
-  defaultIgnore,
-  getFastGlob,
-  getFs,
-  getFsPromises,
-  getPicomatch,
-  matcherCache,
-  normalizeGlobResults,
-  normalizeIgnorePatterns,
-  stripTrailingSlash
-});
+
+//#endregion
+exports.MATCHER_CACHE_MAX_SIZE = MATCHER_CACHE_MAX_SIZE;
+exports.defaultIgnore = require_globs_defaults.defaultIgnore;
+exports.getFastGlob = getFastGlob;
+exports.getFs = require_node_fs.getNodeFs;
+exports.getFsPromises = require_node_fs_promises.getNodeFsPromises;
+exports.getPicomatch = getPicomatch;
+exports.matcherCache = matcherCache;
+exports.normalizeGlobResults = normalizeGlobResults;
+exports.normalizeIgnorePatterns = normalizeIgnorePatterns;
+exports.stripTrailingSlash = stripTrailingSlash;

package/dist/globs/defaults.js

@@ -1,61 +1,42 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"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 defaults_exports = {};
-__export(defaults_exports, {
-  defaultIgnore: () => defaultIgnore
-});
-module.exports = __toCommonJS(defaults_exports);
-var import_mutate = require("../objects/mutate");
-const defaultIgnore = (0, import_mutate.objectFreeze)([
-  // https://docs.npmjs.com/cli/v10/configuring-npm/package-json#files
-  "**/.git",
-  "**/.npmrc",
-  "**/node_modules",
-  // https://github.com/npm/npm-packlist/blob/v10.0.0/lib/index.js#L15-L38
-  "**/.DS_Store",
-  "**/.gitignore",
-  "**/.hg",
-  "**/.lock-wscript",
-  "**/.npmignore",
-  "**/.svn",
-  "**/.wafpickle-*",
-  "**/.*.swp",
-  "**/._*/**",
-  "**/archived-packages/**",
-  "**/build/config.gypi",
-  "**/CVS",
-  "**/npm-debug.log",
-  "**/*.orig",
-  // Inline generic socket-registry .gitignore entries.
-  "**/.env",
-  "**/.eslintcache",
-  "**/.nvm",
-  "**/.tap",
-  "**/.vscode",
-  "**/*.tsbuildinfo",
-  "**/Thumbs.db",
-  // Inline additional ignores.
-  "**/bower_components"
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_objects_mutate = require('../objects/mutate.js');
+
+//#region src/globs/defaults.ts
+/**
+* @file The npm-packlist-derived `defaultIgnore` list. Public starting point
+*   for caller-customized ignore arrays — also consumed internally by
+*   `_internal` (matcher / stream callers fall back to this list when no
+*   `ignore` option is supplied).
+*/
+const defaultIgnore = require_objects_mutate.objectFreeze([
+	"**/.git",
+	"**/.npmrc",
+	"**/node_modules",
+	"**/.DS_Store",
+	"**/.gitignore",
+	"**/.hg",
+	"**/.lock-wscript",
+	"**/.npmignore",
+	"**/.svn",
+	"**/.wafpickle-*",
+	"**/.*.swp",
+	"**/._*/**",
+	"**/archived-packages/**",
+	"**/build/config.gypi",
+	"**/CVS",
+	"**/npm-debug.log",
+	"**/*.orig",
+	"**/.env",
+	"**/.eslintcache",
+	"**/.nvm",
+	"**/.tap",
+	"**/.vscode",
+	"**/*.tsbuildinfo",
+	"**/Thumbs.db",
+	"**/bower_components"
 ]);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  defaultIgnore
-});
+
+//#endregion
+exports.defaultIgnore = defaultIgnore;

package/dist/globs/match.js

@@ -1,84 +1,100 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"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 match_exports = {};
-__export(match_exports, {
-  canUseNodeFsGlob: () => canUseNodeFsGlob,
-  glob: () => glob,
-  globSync: () => globSync
-});
-module.exports = __toCommonJS(match_exports);
-var import_resolvers = require("../promises/resolvers");
-var import_internal = require("./_internal");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_node_fs = require('../node/fs.js');
+const require_node_fs_promises = require('../node/fs-promises.js');
+const require_globs__internal = require('./_internal.js');
+const require_promises_resolvers = require('../promises/resolvers.js');
+
+//#region src/globs/match.ts
+/**
+* @file `glob` (async) and `globSync` — fast-glob wrappers with a
+*   `node:fs.glob` fast-path when the option surface lines up.
+*   `canUseNodeFsGlob` is the per-call gate. Trailing-slash workaround for
+*   fast-glob ignore patterns
+*   ───────────────────────────────────────────────────────── TL;DR: when you
+*   pass `ignore: ['**\/dist/']` to fast-glob, the `dist` directory still gets
+*   walked. Strip the trailing slash before passing it to fast-glob and the
+*   ignore actually takes effect. Why this exists ─────────────── The gitignore
+*   convention is to write directory entries with a trailing slash: `dist/`,
+*   `node_modules/`, `coverage/`. Tools that translate gitignore lines into
+*   glob patterns (including socket-cli's `globWithGitIgnore` helper,
+*   npm-packlist, etc.) preserve that slash. fast-glob has TWO independent
+*   filters that handle the trailing slash differently:
+*
+*   1. The DEEP filter decides whether to walk INTO a candidate directory. The
+*      deep filter compiles `**\/dist/` into a regex that requires a trailing
+*      slash on the input, but it tests `entryPath = 'dist'` (no slash, because
+*      readdir entries don't include one). So fast-glob walks in anyway.
+*   2. The ENTRY filter (post-walk) retries with a trailing slash appended for
+*      directory entries — so it correctly excludes the results, but only AFTER
+*      the entire subtree has been walked. Net effect: a `dist/` ignore pattern
+*      correctly removes contents from the result array, but only after
+*      walking. On a 300k-file `dist/` under tight memory this is the
+*      difference between "instant" and "OOM kill". Stripping the trailing
+*      slash makes it `**\/dist`, which both filters interpret correctly.
+*/
+/**
+* Whether the caller's option bag is fully expressible with `node:fs.glob`
+* (`cwd` + `exclude`). Any other option means we must fall back to fast-glob,
+* which exposes the wider surface.
+*
+* Exported for unit tests; not part of the public API.
+*
+* @internal
+*/
 function canUseNodeFsGlob(options) {
-  if (!options) {
-    return true;
-  }
-  for (const key of Object.keys(options)) {
-    if (key !== "cwd" && key !== "ignore") {
-      return false;
-    }
-  }
-  return true;
+	if (!options) return true;
+	for (const key of Object.keys(options)) if (key !== "cwd" && key !== "ignore") return false;
+	return true;
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Asynchronously find files matching glob patterns.
+*
+* @example
+*   ;```typescript
+*   const files = await glob('src/*.ts', { cwd: '/tmp/project' })
+*   console.log(files) // ['src/index.ts', 'src/utils.ts']
+*   ```
+*/
+/* @__NO_SIDE_EFFECTS__ */
 async function glob(patterns, options) {
-  const normalizedIgnore = (0, import_internal.normalizeIgnorePatterns)(options?.ignore);
-  if (canUseNodeFsGlob(options)) {
-    const out2 = await (0, import_resolvers.fromAsync)(
-      (0, import_internal.getFsPromises)().glob(patterns, {
-        ...options?.cwd ? { cwd: options.cwd } : {},
-        ...normalizedIgnore ? { exclude: normalizedIgnore } : {}
-      })
-    );
-    return (0, import_internal.normalizeGlobResults)(out2);
-  }
-  const fastGlob = (0, import_internal.getFastGlob)();
-  const out = await fastGlob.glob(patterns, {
-    ...options,
-    ...normalizedIgnore ? { ignore: normalizedIgnore } : {}
-  });
-  return (0, import_internal.normalizeGlobResults)(out);
+	const normalizedIgnore = require_globs__internal.normalizeIgnorePatterns(options?.ignore);
+	/* c8 ignore start */
+	if (canUseNodeFsGlob(options)) return require_globs__internal.normalizeGlobResults(await require_promises_resolvers.fromAsync((/* @__PURE__ */ require_node_fs_promises.getNodeFsPromises()).glob(patterns, {
+		...options?.cwd ? { cwd: options.cwd } : {},
+		...normalizedIgnore ? { exclude: normalizedIgnore } : {}
+	})));
+	return require_globs__internal.normalizeGlobResults(await (/* @__PURE__ */ require_globs__internal.getFastGlob()).glob(patterns, {
+		...options,
+		...normalizedIgnore ? { ignore: normalizedIgnore } : {}
+	}));
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Synchronously find files matching glob patterns. Wrapper around
+* fast-glob.sync.
+*
+* @example
+*   ;```typescript
+*   const files = globSync('*.json', { cwd: '/tmp/project' })
+*   console.log(files) // ['package.json', 'tsconfig.json']
+*   ```
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function globSync(patterns, options) {
-  const normalizedIgnore = (0, import_internal.normalizeIgnorePatterns)(options?.ignore);
-  if (canUseNodeFsGlob(options)) {
-    return (0, import_internal.normalizeGlobResults)([
-      ...(0, import_internal.getFs)().globSync(patterns, {
-        ...options?.cwd ? { cwd: options.cwd } : {},
-        ...normalizedIgnore ? { exclude: normalizedIgnore } : {}
-      })
-    ]);
-  }
-  const fastGlob = (0, import_internal.getFastGlob)();
-  return (0, import_internal.normalizeGlobResults)(
-    fastGlob.globSync(patterns, {
-      ...options,
-      ...normalizedIgnore ? { ignore: normalizedIgnore } : {}
-    })
-  );
+	const normalizedIgnore = require_globs__internal.normalizeIgnorePatterns(options?.ignore);
+	/* c8 ignore start */
+	if (canUseNodeFsGlob(options)) return require_globs__internal.normalizeGlobResults([...(/* @__PURE__ */ require_node_fs.getNodeFs()).globSync(patterns, {
+		...options?.cwd ? { cwd: options.cwd } : {},
+		...normalizedIgnore ? { exclude: normalizedIgnore } : {}
+	})]);
+	return require_globs__internal.normalizeGlobResults((/* @__PURE__ */ require_globs__internal.getFastGlob()).globSync(patterns, {
+		...options,
+		...normalizedIgnore ? { ignore: normalizedIgnore } : {}
+	}));
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  canUseNodeFsGlob,
-  glob,
-  globSync
-});
+
+//#endregion
+exports.canUseNodeFsGlob = canUseNodeFsGlob;
+exports.glob = glob;
+exports.globSync = globSync;