@socketsecurity/lib 5.14.0 → 5.16.0

package/dist/packages/edit.d.ts

@@ -83,21 +83,49 @@ export interface EditablePackageJsonInstance {
 }
 /**
  * Get the EditablePackageJson class for package.json manipulation.
+ *
+ * @example
+ * ```typescript
+ * const EditablePackageJson = getEditablePackageJsonClass()
+ * const pkg = await EditablePackageJson.load('/tmp/my-project')
+ * console.log(pkg.content.name)
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function getEditablePackageJsonClass(): EditablePackageJsonConstructor;
 /**
  * Convert a package.json object to an editable instance.
+ *
+ * @example
+ * ```typescript
+ * const editable = pkgJsonToEditable({ name: 'my-pkg', version: '1.0.0' })
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function pkgJsonToEditable(pkgJson: PackageJson, options?: EditablePackageJsonOptions): unknown;
 /**
  * Convert package.json to editable instance with file persistence.
+ *
+ * @example
+ * ```typescript
+ * const editable = await toEditablePackageJson(
+ *   { name: 'my-pkg', version: '1.0.0' },
+ *   { path: '/tmp/my-project' }
+ * )
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function toEditablePackageJson(pkgJson: PackageJson, options?: EditablePackageJsonOptions): Promise<unknown>;
 /**
  * Convert package.json to editable instance with file persistence synchronously.
+ *
+ * @example
+ * ```typescript
+ * const editable = toEditablePackageJsonSync(
+ *   { name: 'my-pkg', version: '1.0.0' },
+ *   { path: '/tmp/my-project' }
+ * )
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function toEditablePackageJsonSync(pkgJson: PackageJson, options?: EditablePackageJsonOptions): unknown;

package/dist/packages/exports.d.ts

@@ -1,30 +1,70 @@
 /**
  * Find types definition for a specific subpath in package exports.
+ *
+ * @example
+ * ```typescript
+ * const exports = { '.': { types: './dist/index.d.ts', import: './dist/index.js' } }
+ * const types = findTypesForSubpath(exports, './dist/index.js')
+ * // types === './dist/index.d.ts'
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function findTypesForSubpath(entryExports: unknown, subpath: string): string | undefined;
 /**
  * Get subpaths from package exports.
+ *
+ * @example
+ * ```typescript
+ * const exports = { '.': './index.js', './utils': './utils.js' }
+ * getSubpaths(exports) // ['.', './utils']
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function getSubpaths(entryExports: unknown): string[];
 /**
  * Get file paths from package exports.
+ *
+ * @example
+ * ```typescript
+ * const exports = { '.': './dist/index.js', './utils': './dist/utils.js' }
+ * getExportFilePaths(exports) // ['./dist/index.js', './dist/utils.js']
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function getExportFilePaths(entryExports: unknown): string[];
 /**
  * Check if package exports use conditional patterns (e.g., import/require).
+ *
+ * @example
+ * ```typescript
+ * isConditionalExports({ import: './index.mjs', require: './index.cjs' }) // true
+ * isConditionalExports({ '.': './index.js' })                            // false
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function isConditionalExports(entryExports: unknown): boolean;
 /**
  * Check if package exports use subpath patterns (keys starting with '.').
+ *
+ * @example
+ * ```typescript
+ * isSubpathExports({ '.': './index.js', './utils': './utils.js' }) // true
+ * isSubpathExports({ import: './index.mjs' })                     // false
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function isSubpathExports(entryExports: unknown): boolean;
 /**
  * Normalize package.json exports field to canonical format.
+ *
+ * @example
+ * ```typescript
+ * resolvePackageJsonEntryExports('./index.js')
+ * // { '.': './index.js' }
+ *
+ * resolvePackageJsonEntryExports({ '.': './index.js' })
+ * // { '.': './index.js' }
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function resolvePackageJsonEntryExports(entryExports: unknown): unknown;

package/dist/packages/licenses.d.ts

@@ -28,41 +28,100 @@ export interface LicenseVisitor {
 }
 /**
  * Collect licenses that are incompatible (copyleft).
+ *
+ * @example
+ * ```typescript
+ * const nodes = [{ license: 'MIT' }, { license: 'GPL-3.0' }]
+ * const incompatible = collectIncompatibleLicenses(nodes)
+ * // incompatible contains only the GPL-3.0 node
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function collectIncompatibleLicenses(licenseNodes: LicenseNode[]): LicenseNode[];
 /**
  * Collect warnings from license nodes.
+ *
+ * @example
+ * ```typescript
+ * const nodes = [{ license: 'UNLICENSED' }]
+ * collectLicenseWarnings(nodes) // ['Package is unlicensed']
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function collectLicenseWarnings(licenseNodes: LicenseNode[]): string[];
 /**
  * Create an AST node from a raw node.
+ *
+ * @example
+ * ```typescript
+ * const raw = { license: 'MIT' }
+ * const node = createAstNode(raw)
+ * // node.type === 'License'
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function createAstNode(rawNode: SpdxAstNode): InternalAstNode;
 /**
  * Create a binary operation AST node.
+ *
+ * @example
+ * ```typescript
+ * const raw = {
+ *   left: { license: 'MIT' },
+ *   conjunction: 'OR' as const,
+ *   right: { license: 'Apache-2.0' }
+ * }
+ * const node = createBinaryOperationNode(raw)
+ * // node.type === 'BinaryOperation'
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function createBinaryOperationNode(rawNodeParam: SpdxBinaryOperationNode): InternalBinaryOperationNode;
 /**
  * Create a license AST node.
+ *
+ * @example
+ * ```typescript
+ * const node = createLicenseNode({ license: 'MIT' })
+ * // node.type === 'License' && node.license === 'MIT'
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function createLicenseNode(rawNode: SpdxLicenseNode): InternalLicenseNode;
 /**
  * Parse an SPDX license expression into an AST.
+ *
+ * @example
+ * ```typescript
+ * const ast = parseSpdxExp('MIT OR Apache-2.0')
+ * // ast is a BinaryOperation node with MIT and Apache-2.0 leaves
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function parseSpdxExp(spdxExp: string): SpdxAstNode | undefined;
 /**
  * Parse package license field into structured license nodes.
+ *
+ * @example
+ * ```typescript
+ * const nodes = resolvePackageLicenses('MIT', '/tmp/my-project')
+ * // [{ license: 'MIT' }]
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function resolvePackageLicenses(licenseFieldValue: string, where: string): LicenseNode[];
 /**
  * Traverse SPDX license AST and invoke visitor callbacks for each node.
+ *
+ * @example
+ * ```typescript
+ * const ast = parseSpdxExp('MIT OR Apache-2.0')
+ * const licenses: string[] = []
+ * if (ast) {
+ *   visitLicenses(ast, { License(node) { licenses.push(node.license) } })
+ * }
+ * // licenses === ['MIT', 'Apache-2.0']
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function visitLicenses(ast: SpdxAstNode, visitor: LicenseVisitor): void;

package/dist/packages/manifest.d.ts

@@ -1,16 +1,34 @@
 import type { PackageJson, PacoteOptions } from '../packages';
 /**
  * Create a package.json object for a Socket registry package.
+ *
+ * @example
+ * ```typescript
+ * const pkgJson = createPackageJson('is-number', 'packages/npm/is-number', {
+ *   version: '1.0.0',
+ *   description: 'Check if a value is a number'
+ * })
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function createPackageJson(sockRegPkgName: string, directory: string, options?: PackageJson | undefined): PackageJson;
 /**
  * Fetch the manifest for a package.
+ *
+ * @example
+ * ```typescript
+ * const manifest = await fetchPackageManifest('lodash@4.17.21')
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function fetchPackageManifest(pkgNameOrId: string, options?: PacoteOptions): Promise<unknown>;
 /**
  * Fetch the packument (package document) for a package.
+ *
+ * @example
+ * ```typescript
+ * const packument = await fetchPackagePackument('lodash')
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function fetchPackagePackument(pkgNameOrId: string, options?: PacoteOptions): Promise<unknown>;

package/dist/packages/normalize.d.ts

@@ -1,21 +1,43 @@
 import type { NormalizeOptions, PackageJson } from '../packages';
 /**
  * Normalize a package.json object with standard npm package normalization.
+ *
+ * @example
+ * ```typescript
+ * const pkgJson = { name: 'my-pkg', version: '1.0.0' }
+ * const normalized = normalizePackageJson(pkgJson)
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function normalizePackageJson(pkgJson: PackageJson, options?: NormalizeOptions): PackageJson;
 /**
  * Extract escaped scope from a Socket registry package name.
+ *
+ * @example
+ * ```typescript
+ * resolveEscapedScope('babel__core') // 'babel__'
+ * resolveEscapedScope('lodash')      // undefined
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function resolveEscapedScope(sockRegPkgName: string): string | undefined;
 /**
  * Resolve original package name from Socket registry package name.
+ *
+ * @example
+ * ```typescript
+ * resolveOriginalPackageName('@socketregistry/is-number') // 'is-number'
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function resolveOriginalPackageName(sockRegPkgName: string): string;
 /**
  * Convert escaped scope to standard npm scope format.
+ *
+ * @example
+ * ```typescript
+ * unescapeScope('babel__') // '@babel'
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function unescapeScope(escapedScope: string): string;

package/dist/packages/operations.d.ts

@@ -1,31 +1,65 @@
 import type { ExtractOptions, NormalizeOptions, PackageJson, PacoteOptions, ReadPackageJsonOptions } from '../packages';
 /**
  * Extract a package to a destination directory.
+ *
+ * @example
+ * ```typescript
+ * await extractPackage('lodash@4.17.21', { dest: '/tmp/lodash' })
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function extractPackage(pkgNameOrId: string, options?: ExtractOptions, callback?: (destPath: string) => Promise<unknown>): Promise<void>;
 /**
  * Find package extensions for a given package.
+ *
+ * @example
+ * ```typescript
+ * const extensions = findPackageExtensions('my-pkg', '1.0.0')
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function findPackageExtensions(pkgName: string, pkgVer: string): unknown;
 /**
  * Get the release tag for a version.
+ *
+ * @example
+ * ```typescript
+ * getReleaseTag('lodash@latest')    // 'latest'
+ * getReleaseTag('@scope/pkg@beta')  // 'beta'
+ * getReleaseTag('lodash')           // ''
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function getReleaseTag(spec: string): string;
 /**
  * Pack a package tarball using pacote.
+ *
+ * @example
+ * ```typescript
+ * const tarball = await packPackage('lodash@4.17.21')
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function packPackage(spec: string, options?: PacoteOptions): Promise<unknown>;
 /**
  * Read and parse a package.json file asynchronously.
+ *
+ * @example
+ * ```typescript
+ * const pkgJson = await readPackageJson('/tmp/my-project')
+ * console.log(pkgJson?.name)
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function readPackageJson(filepath: string, options?: ReadPackageJsonOptions): Promise<PackageJson | undefined>;
 /**
  * Read and parse package.json from a file path synchronously.
+ *
+ * @example
+ * ```typescript
+ * const pkgJson = readPackageJsonSync('/tmp/my-project')
+ * console.log(pkgJson?.name)
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function readPackageJsonSync(filepath: string, options?: NormalizeOptions & {
@@ -34,11 +68,22 @@ export declare function readPackageJsonSync(filepath: string, options?: Normaliz
 }): PackageJson | undefined;
 /**
  * Resolve GitHub tarball URL for a package specifier.
+ *
+ * @example
+ * ```typescript
+ * const url = await resolveGitHubTgzUrl('my-pkg@1.0.0', '/tmp/my-project')
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function resolveGitHubTgzUrl(pkgNameOrId: string, where?: unknown): Promise<string>;
 /**
  * Resolve full package name from a PURL object with custom delimiter.
+ *
+ * @example
+ * ```typescript
+ * resolvePackageName({ name: 'core', namespace: '@babel' })  // '@babel/core'
+ * resolvePackageName({ name: 'lodash' })                     // 'lodash'
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function resolvePackageName(purlObj: {
@@ -47,6 +92,12 @@ export declare function resolvePackageName(purlObj: {
 }, delimiter?: string): string;
 /**
  * Convert npm package name to Socket registry format with delimiter.
+ *
+ * @example
+ * ```typescript
+ * resolveRegistryPackageName('@babel/core') // 'babel__core'
+ * resolveRegistryPackageName('lodash')      // 'lodash'
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function resolveRegistryPackageName(pkgName: string): string;

package/dist/packages/provenance.d.ts

@@ -1,10 +1,21 @@
 import type { ProvenanceOptions } from '../packages';
 /**
  * Convert raw attestation data to user-friendly provenance details.
+ *
+ * @example
+ * ```typescript
+ * const details = getProvenanceDetails(attestationData)
+ * // { level: 'trusted', repository: '...', commitSha: '...' }
+ * ```
  */
 export declare function getProvenanceDetails(attestationData: unknown): unknown;
 /**
  * Fetch package provenance information from npm registry.
+ *
+ * @example
+ * ```typescript
+ * const provenance = await fetchPackageProvenance('lodash', '4.17.21')
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function fetchPackageProvenance(pkgName: string, pkgVersion: string, options?: ProvenanceOptions): Promise<unknown>;

package/dist/packages/specs.d.ts

@@ -1,5 +1,11 @@
 /**
  * Extract user and project from GitHub repository URL.
+ *
+ * @example
+ * ```typescript
+ * getRepoUrlDetails('https://github.com/lodash/lodash.git')
+ * // { user: 'lodash', project: 'lodash' }
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function getRepoUrlDetails(repoUrl?: string): {
@@ -8,21 +14,45 @@ export declare function getRepoUrlDetails(repoUrl?: string): {
 };
 /**
  * Generate GitHub API URL for a tag reference.
+ *
+ * @example
+ * ```typescript
+ * gitHubTagRefUrl('lodash', 'lodash', 'v4.17.21')
+ * // 'https://api.github.com/repos/lodash/lodash/git/ref/tags/v4.17.21'
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function gitHubTagRefUrl(user: string, project: string, tag: string): string;
 /**
  * Generate GitHub tarball download URL for a commit SHA.
+ *
+ * @example
+ * ```typescript
+ * gitHubTgzUrl('lodash', 'lodash', 'abc123')
+ * // 'https://github.com/lodash/lodash/archive/abc123.tar.gz'
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function gitHubTgzUrl(user: string, project: string, sha: string): string;
 /**
  * Check if a package specifier is a GitHub tarball URL.
+ *
+ * @example
+ * ```typescript
+ * isGitHubTgzSpec('https://github.com/user/repo/archive/abc123.tar.gz') // true
+ * isGitHubTgzSpec('lodash@4.17.21')                                     // false
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function isGitHubTgzSpec(spec: unknown, where?: string): boolean;
 /**
  * Check if a package specifier is a GitHub URL with committish.
+ *
+ * @example
+ * ```typescript
+ * isGitHubUrlSpec('github:user/repo#v1.0.0') // true
+ * isGitHubUrlSpec('lodash@4.17.21')           // false
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function isGitHubUrlSpec(spec: unknown, where?: string): boolean;

package/dist/packages/validation.d.ts

@@ -1,15 +1,33 @@
 /**
  * Check if package name is a blessed Socket.dev package.
+ *
+ * @example
+ * ```typescript
+ * isBlessedPackageName('@socketregistry/is-number') // true
+ * isBlessedPackageName('lodash')                    // false
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function isBlessedPackageName(name: unknown): boolean;
 /**
  * Check if a type string represents a registry fetcher type.
+ *
+ * @example
+ * ```typescript
+ * isRegistryFetcherType('range')   // true
+ * isRegistryFetcherType('git')     // false
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function isRegistryFetcherType(type: string): boolean;
 /**
  * Check if a package name is valid according to npm naming rules.
+ *
+ * @example
+ * ```typescript
+ * isValidPackageName('my-package')   // true
+ * isValidPackageName('.invalid')     // false
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function isValidPackageName(name: string): boolean;

package/dist/paths/normalize.d.ts

@@ -141,6 +141,48 @@ export declare function isPath(pathLike: string | Buffer | URL): boolean;
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function isRelative(pathLike: string | Buffer | URL): boolean;
+/**
+ * Convert Unix-style POSIX paths (MSYS/Git Bash format) back to native Windows paths.
+ *
+ * This is the inverse of {@link toUnixPath}. MSYS-style paths use `/c/` notation
+ * for drive letters, which PowerShell and cmd.exe cannot resolve. This function
+ * converts them back to native Windows format.
+ *
+ * Conversion rules:
+ * - On Windows: Converts Unix drive notation to Windows drive letters
+ *   - `/c/path/to/file` becomes `C:/path/to/file`
+ *   - `/d/projects/app` becomes `D:/projects/app`
+ *   - Drive letters are always uppercase in the output
+ * - On Unix: Returns the path unchanged (passes through normalization)
+ *
+ * This is particularly important for:
+ * - GitHub Actions runners where `command -v` returns MSYS paths
+ * - Tools like sfw that need to resolve real binary paths on Windows
+ * - Scripts that receive paths from Git Bash but need to pass them to native Windows tools
+ *
+ * @param {string | Buffer | URL} pathLike - The MSYS/Unix-style path to convert
+ * @returns {string} Native Windows path (e.g., `C:/path/to/file`) or normalized Unix path
+ *
+ * @example
+ * ```typescript
+ * // MSYS drive letter paths
+ * fromUnixPath('/c/projects/app/file.txt')    // 'C:/projects/app/file.txt'
+ * fromUnixPath('/d/projects/foo/bar')         // 'D:/projects/foo/bar'
+ *
+ * // Non-drive Unix paths (unchanged)
+ * fromUnixPath('/tmp/build/output')           // '/tmp/build/output'
+ * fromUnixPath('/usr/local/bin')              // '/usr/local/bin'
+ *
+ * // Already Windows paths (unchanged)
+ * fromUnixPath('C:/Windows/System32')         // 'C:/Windows/System32'
+ *
+ * // Edge cases
+ * fromUnixPath('/c')                          // 'C:/'
+ * fromUnixPath('')                            // '.'
+ * ```
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function fromUnixPath(pathLike: string | Buffer | URL): string;
 /**
  * Normalize a path by converting backslashes to forward slashes and collapsing segments.
  *
@@ -348,21 +390,23 @@ export declare function trimLeadingDotSlash(pathLike: string | Buffer | URL): st
 /*@__NO_SIDE_EFFECTS__*/
 export declare function relativeResolve(from: string, to: string): string;
 /**
- * Convert Windows paths to Unix-style POSIX paths for Git Bash tools.
+ * Convert Windows paths to MSYS/Unix-style POSIX paths for Git Bash tools.
  *
- * Git for Windows tools (like tar, git, etc.) expect POSIX-style paths with
- * forward slashes and Unix drive letter notation (/c/ instead of C:\).
+ * Git for Windows and MSYS2 tools (like tar, git, etc.) expect POSIX-style
+ * paths with forward slashes and Unix drive letter notation (/c/ instead of C:\).
  * This function handles the conversion for cross-platform compatibility.
  *
+ * This is the inverse of {@link fromUnixPath}.
+ *
  * Conversion rules:
  * - On Windows: Normalizes separators and converts drive letters
  *   - `C:\path\to\file` becomes `/c/path/to/file`
- *   - `D:/Users/name` becomes `/d/Users/name`
+ *   - `D:/projects/app` becomes `/d/projects/app`
  *   - Drive letters are always lowercase in the output
  * - On Unix: Returns the path unchanged (passes through normalization)
  *
  * This is particularly important for:
- * - Git Bash tools that interpret `D:\` as a remote hostname
+ * - MSYS2/Git Bash tools that interpret `D:\` as a remote hostname
  * - Cross-platform build scripts using tar, git archive, etc.
  * - CI/CD environments where Git for Windows is used
  *

package/dist/paths/normalize.js

@@ -19,6 +19,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var normalize_exports = {};
 __export(normalize_exports, {
+  fromUnixPath: () => fromUnixPath,
   isAbsolute: () => isAbsolute,
   isNodeModules: () => isNodeModules,
   isPath: () => isPath,
@@ -130,6 +131,17 @@ function isRelative(pathLike) {
   return !/* @__PURE__ */ isAbsolute(filepath);
 }
 // @__NO_SIDE_EFFECTS__
+function fromUnixPath(pathLike) {
+  const normalized = /* @__PURE__ */ normalizePath(pathLike);
+  if (import_platform.WIN32) {
+    return normalized.replace(
+      /^\/([a-zA-Z])(\/|$)/,
+      (_, letter, sep) => `${letter.toUpperCase()}:${sep || "/"}`
+    );
+  }
+  return normalized;
+}
+// @__NO_SIDE_EFFECTS__
 function normalizePath(pathLike) {
   const filepath = /* @__PURE__ */ pathLikeToString(pathLike);
   const { length } = filepath;
@@ -448,6 +460,7 @@ function toUnixPath(pathLike) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  fromUnixPath,
   isAbsolute,
   isNodeModules,
   isPath,

package/dist/paths/rewire.js

@@ -28,9 +28,18 @@ __export(rewire_exports, {
   setPath: () => setPath
 });
 module.exports = __toCommonJS(rewire_exports);
-const testOverrides = /* @__PURE__ */ new Map();
-const valueCache = /* @__PURE__ */ new Map();
-const cacheInvalidationCallbacks = [];
+const stateSymbol = Symbol.for("@socketsecurity/lib/paths/rewire/state");
+if (!globalThis[stateSymbol]) {
+  globalThis[stateSymbol] = {
+    testOverrides: /* @__PURE__ */ new Map(),
+    valueCache: /* @__PURE__ */ new Map(),
+    cacheInvalidationCallbacks: []
+  };
+}
+const sharedState = globalThis[stateSymbol];
+const testOverrides = sharedState.testOverrides;
+const valueCache = sharedState.valueCache;
+const cacheInvalidationCallbacks = sharedState.cacheInvalidationCallbacks;
 function clearPath(key) {
   testOverrides.delete(key);
   invalidateCaches();

package/dist/regexps.d.ts

@@ -8,6 +8,13 @@
 // Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
 /**
  * Escape special characters in a string for use in a regular expression.
+ *
+ * @example
+ * ```typescript
+ * escapeRegExp('foo.bar')     // 'foo\\.bar'
+ * escapeRegExp('a+b*c?')     // 'a\\+b\\*c\\?'
+ * new RegExp(escapeRegExp('[test]'))  // /\[test\]/
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function escapeRegExp(str: string): string;