@socketsecurity/lib 6.0.8 → 6.0.10

package/dist/external/npm-package-arg.d.ts

@@ -0,0 +1,4 @@
+import type { NpmPack } from './npm-pack'
+
+declare const npmPackageArg: NpmPack['npmPackageArg']
+export default npmPackageArg

package/dist/external/p-map.js

@@ -21,7 +21,14 @@ var __name = (target, value) => __defProp(target, "name", {
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __esmMin = (fn, res, err) => () => {
+	if (err) throw err[0];
+	try {
+		return fn && (res = fn(fn = 0)), res;
+	} catch (e) {
+		throw err = [e], e;
+	}
+};
 var __exportAll = (all, no_symbols) => {
 	let target = {};
 	for (var name in all) {

package/dist/external/pacote.d.ts

@@ -0,0 +1,15 @@
+export class RegistryFetcher {
+  constructor(spec: string, opts?: any)
+  cache: string
+}
+
+export interface Pacote {
+  RegistryFetcher: typeof RegistryFetcher
+  extract(spec: string, dest: string, opts?: any): Promise<any>
+  manifest(spec: string, opts?: any): Promise<any>
+  packument(spec: string, opts?: any): Promise<any>
+  tarball(spec: string, opts?: any): Promise<Buffer>
+}
+
+declare const pacote: Pacote
+export default pacote

package/dist/external/pico-pack.d.ts

@@ -0,0 +1,16 @@
+import type * as delTypes from 'del'
+import type * as fastGlobTypes from 'fast-glob'
+import type picomatchType from 'picomatch'
+
+export interface PicoPack {
+  del: Pick<typeof delTypes, 'deleteAsync' | 'deleteSync'>
+  glob: {
+    glob: typeof fastGlobTypes.glob
+    globStream: typeof fastGlobTypes.globStream
+    globSync: typeof fastGlobTypes.sync
+  }
+  picomatch: typeof picomatchType
+}
+
+declare const picoPack: PicoPack
+export default picoPack

package/dist/external/pico-pack.js

@@ -16,7 +16,14 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __esmMin = (fn, res, err) => () => {
+	if (err) throw err[0];
+	try {
+		return fn && (res = fn(fn = 0)), res;
+	} catch (e) {
+		throw err = [e], e;
+	}
+};
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -52,20 +59,20 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 //#endregion
-let node_fs = require("node:fs");
+let node_fs = require("fs");
 node_fs = __toESM(node_fs, 1);
-let node_fs_promises = require("node:fs/promises");
+let node_fs_promises = require("fs/promises");
 node_fs_promises = __toESM(node_fs_promises, 1);
-let node_path = require("node:path");
+let node_path = require("path");
 node_path = __toESM(node_path, 1);
-let node_process = require("node:process");
+let node_process = require("process");
 node_process = __toESM(node_process, 1);
-let node_events = require("node:events");
-let node_stream = require("node:stream");
-let node_stream_promises = require("node:stream/promises");
-let node_util = require("node:util");
-let node_child_process = require("node:child_process");
-let node_url = require("node:url");
+let node_events = require("events");
+let node_stream = require("stream");
+let node_stream_promises = require("stream/promises");
+let node_util = require("util");
+let node_child_process = require("child_process");
+let node_url = require("url");
 
 const { ArrayIsArray: _p_ArrayIsArray, ArrayPrototypeFlatMap: _p_ArrayPrototypeFlatMap, ArrayPrototypeUnshift: _p_ArrayPrototypeUnshift } = require('../primordials/array.js')
 
@@ -945,7 +952,8 @@ var require_parse$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		};
 		const extglobClose = (token) => {
 			const literal = input.slice(token.startIndex, state.index + 1);
-			const analysis = analyzeRepeatedExtglob(input.slice(token.startIndex + 2, state.index), opts);
+			const body = input.slice(token.startIndex + 2, state.index);
+			const analysis = analyzeRepeatedExtglob(body, opts);
 			if ((token.type === "plus" || token.type === "star") && analysis.risky) {
 				const safeOutput = analysis.safeOutput ? (token.output ? "" : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) : void 0;
 				const open = tokens[token.tokensIndex];
@@ -1071,7 +1079,8 @@ var require_parse$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 						if (inner.includes(":")) {
 							const idx = prev.value.lastIndexOf("[");
 							const pre = prev.value.slice(0, idx);
-							const posix = POSIX_REGEX_SOURCE[prev.value.slice(idx + 2)];
+							const rest = prev.value.slice(idx + 2);
+							const posix = POSIX_REGEX_SOURCE[rest];
 							if (posix) {
 								prev.value = pre + posix;
 								state.backtrack = true;
@@ -2593,7 +2602,7 @@ var require_to_regex_range = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 		let nines = 1;
 		let zeros = 1;
 		let stop = countNines(min, nines);
-		let stops = new _p_SetCtor([max]);
+		let stops = /* @__PURE__ */ new _p_SetCtor([max]);
 		while (min <= stop && stop <= max) {
 			stops.add(stop);
 			nines += 1;
@@ -4577,7 +4586,8 @@ var require_async$4 = /* @__PURE__ */ __commonJSMin(((exports) => {
 				callSuccessCallback(callback, entries);
 				return;
 			}
-			rpl(entries.map((entry) => makeRplTaskEntry(entry, settings)), (rplError, rplEntries) => {
+			const tasks = entries.map((entry) => makeRplTaskEntry(entry, settings));
+			rpl(tasks, (rplError, rplEntries) => {
 				if (rplError !== null) {
 					callFailureCallback(callback, rplError);
 					return;
@@ -4613,7 +4623,7 @@ var require_async$4 = /* @__PURE__ */ __commonJSMin(((exports) => {
 				callFailureCallback(callback, readdirError);
 				return;
 			}
-			rpl(names.map((name) => {
+			const tasks = names.map((name) => {
 				const path = common.joinPathSegments(directory, name, settings.pathSegmentSeparator);
 				return (done) => {
 					fsStat.stat(path, settings.fsStatSettings, (error, stats) => {
@@ -4630,7 +4640,8 @@ var require_async$4 = /* @__PURE__ */ __commonJSMin(((exports) => {
 						done(null, entry);
 					});
 				};
-			}), (rplError, entries) => {
+			});
+			rpl(tasks, (rplError, entries) => {
 				if (rplError !== null) {
 					callFailureCallback(callback, rplError);
 					return;
@@ -6432,14 +6443,15 @@ var init_ignore = __esmMin((() => {
 			ignore,
 			...ignoreFilesGlobOptions
 		});
-		return getIsIgnoredPredicate(await _p_PromiseAll(paths.map(async (filePath) => ({
+		const files = await _p_PromiseAll(paths.map(async (filePath) => ({
 			filePath,
 			content: await node_fs_promises.default.readFile(filePath, "utf8")
-		}))), cwd);
+		})));
+		return getIsIgnoredPredicate(files, cwd);
 	};
 	isIgnoredByIgnoreFilesSync = (patterns, options) => {
 		const { cwd, suppressErrors, deep, ignore } = normalizeOptions$1(options);
-		return getIsIgnoredPredicate(import_out$1.default.sync(patterns, {
+		const files = import_out$1.default.sync(patterns, {
 			cwd,
 			suppressErrors,
 			deep,
@@ -6448,7 +6460,8 @@ var init_ignore = __esmMin((() => {
 		}).map((filePath) => ({
 			filePath,
 			content: node_fs.default.readFileSync(filePath, "utf8")
-		})), cwd);
+		}));
+		return getIsIgnoredPredicate(files, cwd);
 	};
 }));
 
@@ -6595,12 +6608,14 @@ var init_globby = __esmMin((() => {
 	};
 	globby = normalizeArguments(async (patterns, options) => {
 		const [tasks, filter] = await _p_PromiseAll([generateTasks(patterns, options), getFilter(options)]);
-		return unionFastGlobResults(await _p_PromiseAll(tasks.map((task) => (0, import_out.default)(task.patterns, task.options))), filter);
+		const results = await _p_PromiseAll(tasks.map((task) => (0, import_out.default)(task.patterns, task.options)));
+		return unionFastGlobResults(results, filter);
 	});
 	globbySync = normalizeArgumentsSync((patterns, options) => {
 		const tasks = generateTasksSync(patterns, options);
 		const filter = getFilterSync(options);
-		return unionFastGlobResults(tasks.map((task) => import_out.default.sync(task.patterns, task.options)), filter);
+		const results = tasks.map((task) => import_out.default.sync(task.patterns, task.options));
+		return unionFastGlobResults(results, filter);
 	});
 	globbyStream = normalizeArgumentsSync((patterns, options) => {
 		const tasks = generateTasksSync(patterns, options);

package/dist/external/picomatch.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Picomatch options for glob pattern matching.
+ */
+export interface PicomatchOptions {
+  /**
+   * When true, the glob will match the basename of the path.
+   *
+   * @default false
+   */
+  basename?: boolean
+
+  /**
+   * When true, the glob will match case-insensitively.
+   *
+   * @default false
+   */
+  nocase?: boolean
+
+  /**
+   * When true, allow matching dotfiles (files starting with '.').
+   *
+   * @default false
+   */
+  dot?: boolean
+
+  /**
+   * Glob patterns to ignore.
+   */
+  ignore?: string | string[]
+
+  /**
+   * When true, a leading '!' will negate the glob.
+   *
+   * @default true
+   */
+  negate?: boolean
+
+  /**
+   * When true, match against Windows paths. Defaults to os.platform() ===
+   * 'win32'.
+   */
+  windows?: boolean
+
+  /**
+   * When true, convert backslashes to forward slashes in paths.
+   *
+   * @default true on Windows
+   */
+  normalize?: boolean
+
+  /**
+   * Function to call on each match result.
+   */
+  onMatch?: (result: unknown) => void
+
+  /**
+   * Function to call on each result.
+   */
+  onResult?: (result: unknown) => void
+
+  /**
+   * Format function for transforming paths.
+   */
+  format?: (input: string) => string
+}
+
+/**
+ * Matcher function returned by picomatch. Tests if a string matches the glob
+ * pattern.
+ */
+export type Matcher = (input: string) => boolean
+
+/**
+ * Creates a matcher function from a glob pattern. The returned function takes a
+ * string to match as its argument.
+ *
+ * @example
+ *   ;```ts
+ *   import picomatch from './external/picomatch.js'
+ *
+ *   const isMatch = picomatch('*.js')
+ *   isMatch('test.js') // true
+ *   isMatch('test.ts') // false
+ *   ```
+ *
+ * @param pattern - Glob pattern to match against.
+ * @param options - Picomatch options.
+ *
+ * @returns Matcher function that tests strings against the pattern
+ */
+declare function picomatch(
+  pattern: string | string[],
+  options?: PicomatchOptions,
+): Matcher
+
+export default picomatch

package/dist/external/pony-cause.d.ts

@@ -0,0 +1,14 @@
+export class ErrorWithCause extends Error {
+  constructor(message: string, options?: { cause?: unknown })
+}
+
+export function findCauseByReference(
+  error: Error,
+  reference: Error,
+): Error | undefined
+
+export function getErrorCause(error: Error): Error | undefined
+
+export function stackWithCauses(error: Error): string
+
+export function messageWithCauses(error: Error): string

package/dist/external/semver.d.ts

@@ -0,0 +1,60 @@
+export interface SemVerParsed {
+  version: string
+  major: number
+  minor: number
+  patch: number
+  prerelease: ReadonlyArray<string | number>
+  build: readonly string[]
+}
+
+export function coerce(version: string | number): { version: string } | null
+export function compare(v1: string, v2: string): -1 | 0 | 1
+export function satisfies(
+  version: string,
+  range: string,
+  options?: RangeOptions | boolean,
+): boolean
+export function parse(version: string): SemVerParsed | null
+export function inc(
+  version: string,
+  release: string,
+  identifier?: string,
+): string | null
+export function eq(version1: string, version2: string): boolean
+export function gt(version1: string, version2: string): boolean
+export function gte(version1: string, version2: string): boolean
+export function lt(version1: string, version2: string): boolean
+export function lte(version1: string, version2: string): boolean
+export function valid(
+  version: string,
+  options?: RangeOptions | boolean,
+): string | null
+export interface RangeOptions {
+  includePrerelease?: boolean
+  loose?: boolean
+}
+export function maxSatisfying(
+  versions: string[],
+  range: string,
+  options?: RangeOptions | boolean,
+): string | null
+export function minSatisfying(
+  versions: string[],
+  range: string,
+  options?: RangeOptions | boolean,
+): string | null
+export function sort(versions: string[]): string[]
+export function rsort(versions: string[]): string[]
+export function diff(
+  version1: string,
+  version2: string,
+):
+  | 'major'
+  | 'premajor'
+  | 'minor'
+  | 'preminor'
+  | 'patch'
+  | 'prepatch'
+  | 'prerelease'
+  | 'release'
+  | null