@socketsecurity/lib 5.28.0 → 6.0.0

package/dist/packages/exports.js

@@ -28,40 +28,44 @@ __export(exports_exports, {
   resolvePackageJsonEntryExports: () => resolvePackageJsonEntryExports
 });
 module.exports = __toCommonJS(exports_exports);
-var import_arrays = require("../arrays");
-var import_core = require("../constants/core");
-var import_objects = require("../objects");
-var import_primordials = require("../primordials");
+var import_predicates = require("../arrays/predicates");
+var import_sentinels = require("../constants/sentinels");
+var import_predicates2 = require("../objects/predicates");
+var import_array = require("../primordials/array");
+var import_error = require("../primordials/error");
+var import_map_set = require("../primordials/map-set");
+var import_object = require("../primordials/object");
+var import_string = require("../primordials/string");
 // @__NO_SIDE_EFFECTS__
 function findTypesForSubpath(entryExports, subpath) {
   const queue = [entryExports];
   let pos = 0;
   while (pos < queue.length) {
-    if (pos === import_core.LOOP_SENTINEL) {
-      throw new import_primordials.ErrorCtor(
+    if (pos === import_sentinels.LOOP_SENTINEL) {
+      throw new import_error.ErrorCtor(
         "Detected infinite loop in entry exports crawl of getTypesForSubpath"
       );
     }
     const value = queue[pos++];
-    if ((0, import_arrays.isArray)(value)) {
+    if ((0, import_predicates.isArray)(value)) {
       for (let i = 0, { length } = value; i < length; i += 1) {
         const item = value[i];
         if (item === subpath) {
           return value.types;
         }
-        if ((0, import_objects.isObject)(item)) {
+        if ((0, import_predicates2.isObject)(item)) {
           queue.push(item);
         }
       }
-    } else if ((0, import_objects.isObject)(value)) {
-      const keys = (0, import_primordials.ObjectGetOwnPropertyNames)(value);
+    } else if ((0, import_predicates2.isObject)(value)) {
+      const keys = (0, import_object.ObjectGetOwnPropertyNames)(value);
       for (let i = 0, { length } = keys; i < length; i += 1) {
         const key = keys[i];
         const item = value[key];
         if (item === subpath) {
           return value.types;
         }
-        if ((0, import_objects.isObject)(item)) {
+        if ((0, import_predicates2.isObject)(item)) {
           queue.push(item);
         }
       }
@@ -71,31 +75,31 @@ function findTypesForSubpath(entryExports, subpath) {
 }
 // @__NO_SIDE_EFFECTS__
 function getExportFilePaths(entryExports) {
-  if (!(0, import_objects.isObject)(entryExports)) {
+  if (!(0, import_predicates2.isObject)(entryExports)) {
     return [];
   }
   const paths = [];
-  for (const key of (0, import_primordials.ObjectGetOwnPropertyNames)(entryExports)) {
-    if (!(0, import_primordials.StringPrototypeStartsWith)(key, ".")) {
+  for (const key of (0, import_object.ObjectGetOwnPropertyNames)(entryExports)) {
+    if (!(0, import_string.StringPrototypeStartsWith)(key, ".")) {
       continue;
     }
     const value = entryExports[key];
     if (typeof value === "string") {
-      (0, import_primordials.ArrayPrototypePush)(paths, value);
-    } else if ((0, import_objects.isObject)(value)) {
-      for (const subKey of (0, import_primordials.ObjectGetOwnPropertyNames)(value)) {
+      (0, import_array.ArrayPrototypePush)(paths, value);
+    } else if ((0, import_predicates2.isObject)(value)) {
+      for (const subKey of (0, import_object.ObjectGetOwnPropertyNames)(value)) {
         const subValue = value[subKey];
         if (typeof subValue === "string") {
-          (0, import_primordials.ArrayPrototypePush)(paths, subValue);
-        } else if ((0, import_arrays.isArray)(subValue)) {
+          (0, import_array.ArrayPrototypePush)(paths, subValue);
+        } else if ((0, import_predicates.isArray)(subValue)) {
           for (const item of subValue) {
             if (typeof item === "string") {
-              (0, import_primordials.ArrayPrototypePush)(paths, item);
-            } else if ((0, import_objects.isObject)(item)) {
-              for (const nestedKey of (0, import_primordials.ObjectGetOwnPropertyNames)(item)) {
+              (0, import_array.ArrayPrototypePush)(paths, item);
+            } else if ((0, import_predicates2.isObject)(item)) {
+              for (const nestedKey of (0, import_object.ObjectGetOwnPropertyNames)(item)) {
                 const nestedValue = item[nestedKey];
                 if (typeof nestedValue === "string") {
-                  (0, import_primordials.ArrayPrototypePush)(paths, nestedValue);
+                  (0, import_array.ArrayPrototypePush)(paths, nestedValue);
                 }
               }
             }
@@ -104,30 +108,30 @@ function getExportFilePaths(entryExports) {
       }
     }
   }
-  return [...new import_primordials.SetCtor(paths)].filter((p) => (0, import_primordials.StringPrototypeStartsWith)(p, "./"));
+  return [...new import_map_set.SetCtor(paths)].filter((p) => (0, import_string.StringPrototypeStartsWith)(p, "./"));
 }
 // @__NO_SIDE_EFFECTS__
 function getSubpaths(entryExports) {
-  if (!(0, import_objects.isObject)(entryExports)) {
+  if (!(0, import_predicates2.isObject)(entryExports)) {
     return [];
   }
-  return (0, import_primordials.ObjectGetOwnPropertyNames)(entryExports).filter(
-    (key) => (0, import_primordials.StringPrototypeStartsWith)(key, ".")
+  return (0, import_object.ObjectGetOwnPropertyNames)(entryExports).filter(
+    (key) => (0, import_string.StringPrototypeStartsWith)(key, ".")
   );
 }
 // @__NO_SIDE_EFFECTS__
 function isConditionalExports(entryExports) {
-  if (!(0, import_objects.isObjectObject)(entryExports)) {
+  if (!(0, import_predicates2.isPlainObject)(entryExports)) {
     return false;
   }
-  const keys = (0, import_primordials.ObjectGetOwnPropertyNames)(entryExports);
+  const keys = (0, import_object.ObjectGetOwnPropertyNames)(entryExports);
   const { length } = keys;
   if (!length) {
     return false;
   }
   for (let i = 0; i < length; i += 1) {
     const key = keys[i];
-    if (key.length > 0 && (0, import_primordials.StringPrototypeCharCodeAt)(key, 0) === 46) {
+    if (key.length > 0 && (0, import_string.StringPrototypeCharCodeAt)(key, 0) === 46) {
       return false;
     }
   }
@@ -135,8 +139,8 @@ function isConditionalExports(entryExports) {
 }
 // @__NO_SIDE_EFFECTS__
 function isSubpathExports(entryExports) {
-  if ((0, import_objects.isObjectObject)(entryExports)) {
-    const keys = (0, import_primordials.ObjectGetOwnPropertyNames)(entryExports);
+  if ((0, import_predicates2.isPlainObject)(entryExports)) {
+    const keys = (0, import_object.ObjectGetOwnPropertyNames)(entryExports);
     for (let i = 0, { length } = keys; i < length; i += 1) {
       if (keys[i]?.charCodeAt(0) === 46) {
         return true;
@@ -147,13 +151,13 @@ function isSubpathExports(entryExports) {
 }
 // @__NO_SIDE_EFFECTS__
 function resolvePackageJsonEntryExports(entryExports) {
-  if (typeof entryExports === "string" || (0, import_arrays.isArray)(entryExports)) {
+  if (typeof entryExports === "string" || (0, import_predicates.isArray)(entryExports)) {
     return { ".": entryExports };
   }
   if (/* @__PURE__ */ isConditionalExports(entryExports)) {
     return entryExports;
   }
-  return (0, import_objects.isObject)(entryExports) ? entryExports : void 0;
+  return (0, import_predicates2.isObject)(entryExports) ? entryExports : void 0;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/packages/isolation.d.ts

@@ -1,8 +1,8 @@
 /**
- * @fileoverview Package isolation utilities for testing.
- * Provides tools to set up isolated test environments for packages.
+ * @file Package isolation utilities for testing. Provides tools to set up
+ *   isolated test environments for packages.
  */
-import type { PackageJson } from '../packages';
+import type { PackageJson } from './types';
 export type IsolatePackageOptions = {
     imports?: Record<string, string> | undefined;
     install?: ((cwd: string) => Promise<void>) | undefined;
@@ -16,11 +16,20 @@ export type IsolatePackageResult = {
 /**
  * Isolates a package in a temporary test environment.
  *
- * Supports multiple input types:
- * 1. File system path (absolute or relative)
- * 2. Package name with optional version spec
- * 3. npm package spec (parsed via npm-package-arg)
+ * Supports multiple input types: 1. File system path (absolute or relative) 2.
+ * Package name with optional version spec 3. npm package spec (parsed via
+ * npm-package-arg)
  *
  * @throws {Error} When package installation or setup fails.
  */
 export declare function isolatePackage(packageSpec: string, options?: IsolatePackageOptions | undefined): Promise<IsolatePackageResult>;
+/**
+ * Merge and write package.json with original and new values.
+ */
+export declare function mergePackageJson(pkgJsonPath: string, originalPkgJson: PackageJson | undefined): Promise<PackageJson>;
+/**
+ * Resolve a path to its real location, handling symlinks. Falls back to a
+ * non-realpath resolution if the OS rejects the lookup (ENOENT, EACCES, etc.) —
+ * caller still gets a usable absolute path either way.
+ */
+export declare function resolveRealPath(pathStr: string): Promise<string>;

package/dist/packages/isolation.js

@@ -30,66 +30,35 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var isolation_exports = {};
 __export(isolation_exports, {
-  isolatePackage: () => isolatePackage
+  isolatePackage: () => isolatePackage,
+  mergePackageJson: () => mergePackageJson,
+  resolveRealPath: () => resolveRealPath
 });
 module.exports = __toCommonJS(isolation_exports);
 var import_npm_package_arg = __toESM(require("../external/npm-package-arg"));
 var import_platform = require("../constants/platform");
-var import_errors = require("../errors");
+var import_message = require("../errors/message");
 var import_normalize = require("../paths/normalize");
 var import_socket = require("../paths/socket");
-var import_spawn = require("../spawn");
+var import_spawn = require("../spawn/spawn");
 var import_operations = require("./operations");
-var import_primordials = require("../primordials");
+var import_error = require("../primordials/error");
+var import_json = require("../primordials/json");
+var import_object = require("../primordials/object");
+var import_string = require("../primordials/string");
+var import_fs = require("../node/fs");
+var import_path = require("../node/path");
 const FS_CP_OPTIONS = {
   dereference: true,
   errorOnExist: false,
-  filter: (src) => !src.includes("node_modules") && !(0, import_primordials.StringPrototypeEndsWith)(src, ".DS_Store"),
+  filter: (src) => !src.includes("node_modules") && !(0, import_string.StringPrototypeEndsWith)(src, ".DS_Store"),
   force: true,
   recursive: true,
   ...import_platform.WIN32 ? { maxRetries: 3, retryDelay: 100 } : {}
 };
-let _fs;
-let _path;
-// @__NO_SIDE_EFFECTS__
-function getFs() {
-  if (_fs === void 0) {
-    _fs = require("node:fs");
-  }
-  return _fs;
-}
-// @__NO_SIDE_EFFECTS__
-function getPath() {
-  if (_path === void 0) {
-    _path = require("node:path");
-  }
-  return _path;
-}
-async function mergePackageJson(pkgJsonPath, originalPkgJson) {
-  const fs = /* @__PURE__ */ getFs();
-  let pkgJson;
-  try {
-    pkgJson = (0, import_primordials.JSONParse)(await fs.promises.readFile(pkgJsonPath, "utf8"));
-  } catch (e) {
-    throw new import_primordials.ErrorCtor(`Failed to parse ${pkgJsonPath}: ${(0, import_errors.errorMessage)(e)}`, {
-      cause: e
-    });
-  }
-  const mergedPkgJson = originalPkgJson ? { ...originalPkgJson, ...pkgJson } : pkgJson;
-  return mergedPkgJson;
-}
-async function resolveRealPath(pathStr) {
-  const fs = /* @__PURE__ */ getFs();
-  const path = /* @__PURE__ */ getPath();
-  try {
-    return await fs.promises.realpath(pathStr);
-  } catch {
-    return path.resolve(pathStr);
-  }
-}
 async function isolatePackage(packageSpec, options) {
-  const fs = /* @__PURE__ */ getFs();
-  const path = /* @__PURE__ */ getPath();
+  const fs = (0, import_fs.getNodeFs)();
+  const path = (0, import_path.getNodePath)();
   const opts = { __proto__: null, ...options };
   const { imports, install, onPackageJson, sourcePath: optSourcePath } = opts;
   let sourcePath = optSourcePath;
@@ -100,11 +69,11 @@ async function isolatePackage(packageSpec, options) {
     const pathToResolve = (0, import_normalize.isAbsolute)(trimmedPath) ? trimmedPath : packageSpec;
     sourcePath = path.resolve(pathToResolve);
     if (!fs.existsSync(sourcePath)) {
-      throw new import_primordials.ErrorCtor(`Source path does not exist: ${sourcePath}`);
+      throw new import_error.ErrorCtor(`Source path does not exist: ${sourcePath}`);
     }
     const pkgJson = await (0, import_operations.readPackageJson)(sourcePath, { normalize: true });
     if (!pkgJson) {
-      throw new import_primordials.ErrorCtor(`Could not read package.json from: ${sourcePath}`);
+      throw new import_error.ErrorCtor(`Could not read package.json from: ${sourcePath}`);
     }
     packageName = pkgJson.name;
   } else {
@@ -113,12 +82,12 @@ async function isolatePackage(packageSpec, options) {
     if (parsed.type === "directory" || parsed.type === "file") {
       sourcePath = parsed.fetchSpec;
       if (!sourcePath || !fs.existsSync(sourcePath)) {
-        throw new import_primordials.ErrorCtor(`Source path does not exist: ${sourcePath}`);
+        throw new import_error.ErrorCtor(`Source path does not exist: ${sourcePath}`);
       }
       if (!packageName) {
         const pkgJson = await (0, import_operations.readPackageJson)(sourcePath, { normalize: true });
         if (!pkgJson) {
-          throw new import_primordials.ErrorCtor(`Could not read package.json from: ${sourcePath}`);
+          throw new import_error.ErrorCtor(`Could not read package.json from: ${sourcePath}`);
         }
         packageName = pkgJson.name;
       }
@@ -127,7 +96,7 @@ async function isolatePackage(packageSpec, options) {
     }
   }
   if (!packageName) {
-    throw new import_primordials.ErrorCtor(`Could not determine package name from: ${packageSpec}`);
+    throw new import_error.ErrorCtor(`Could not determine package name from: ${packageSpec}`);
   }
   const sanitizedName = packageName.replace(/[@/]/g, "-");
   const tempDir = await fs.promises.mkdtemp(
@@ -140,7 +109,7 @@ async function isolatePackage(packageSpec, options) {
   if (spec) {
     await fs.promises.writeFile(
       path.join(packageTempDir, "package.json"),
-      JSON.stringify(
+      (0, import_json.JSONStringify)(
         {
           name: "test-temp",
           private: true,
@@ -153,7 +122,7 @@ async function isolatePackage(packageSpec, options) {
     if (install) {
       await install(packageTempDir);
     } else {
-      const packageInstallSpec = (0, import_primordials.StringPrototypeStartsWith)(spec, "https://") ? spec : `${packageName}@${spec}`;
+      const packageInstallSpec = (0, import_string.StringPrototypeStartsWith)(spec, "https://") ? spec : `${packageName}@${spec}`;
       await (0, import_spawn.spawn)("pnpm", ["add", packageInstallSpec], {
         cwd: packageTempDir,
         shell: import_platform.WIN32,
@@ -173,11 +142,11 @@ async function isolatePackage(packageSpec, options) {
     }
   } else {
     if (!sourcePath) {
-      throw new import_primordials.ErrorCtor(
+      throw new import_error.ErrorCtor(
         "sourcePath is required when no version spec provided"
       );
     }
-    const scopedPath = (0, import_primordials.StringPrototypeStartsWith)(packageName, "@") ? path.join(
+    const scopedPath = (0, import_string.StringPrototypeStartsWith)(packageName, "@") ? path.join(
       packageTempDir,
       "node_modules",
       packageName.split("/")[0] ?? ""
@@ -195,7 +164,7 @@ async function isolatePackage(packageSpec, options) {
     const finalPkgJson = onPackageJson ? await onPackageJson(mergedPkgJson) : mergedPkgJson;
     await fs.promises.writeFile(
       pkgJsonPath,
-      JSON.stringify(finalPkgJson, null, 2)
+      (0, import_json.JSONStringify)(finalPkgJson, null, 2)
     );
   }
   if (install) {
@@ -209,7 +178,7 @@ async function isolatePackage(packageSpec, options) {
   }
   const exports2 = imports ? { __proto__: null } : void 0;
   if (imports) {
-    for (const { 0: key, 1: specifier } of (0, import_primordials.ObjectEntries)(imports)) {
+    for (const { 0: key, 1: specifier } of (0, import_object.ObjectEntries)(imports)) {
       const fullPath = path.join(installedPath, specifier);
       exports2[key] = require(fullPath);
     }
@@ -219,7 +188,31 @@ async function isolatePackage(packageSpec, options) {
     tmpdir: installedPath
   };
 }
+async function mergePackageJson(pkgJsonPath, originalPkgJson) {
+  const fs = (0, import_fs.getNodeFs)();
+  let pkgJson;
+  try {
+    pkgJson = (0, import_json.JSONParse)(await fs.promises.readFile(pkgJsonPath, "utf8"));
+  } catch (e) {
+    throw new import_error.ErrorCtor(`Failed to parse ${pkgJsonPath}: ${(0, import_message.errorMessage)(e)}`, {
+      cause: e
+    });
+  }
+  const mergedPkgJson = originalPkgJson ? { ...originalPkgJson, ...pkgJson } : pkgJson;
+  return mergedPkgJson;
+}
+async function resolveRealPath(pathStr) {
+  const fs = (0, import_fs.getNodeFs)();
+  const path = (0, import_path.getNodePath)();
+  try {
+    return await fs.promises.realpath(pathStr);
+  } catch {
+    return path.resolve(pathStr);
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  isolatePackage
+  isolatePackage,
+  mergePackageJson,
+  resolveRealPath
 });

package/dist/packages/licenses.d.ts

@@ -1,7 +1,7 @@
 /**
- * @fileoverview SPDX license parsing and analysis utilities.
+ * @file SPDX license parsing and analysis utilities.
  */
-import type { LicenseNode } from '../packages';
+import type { LicenseNode } from './types';
 export interface SpdxLicenseNode {
     license: string;
     plus?: boolean | undefined;
@@ -31,90 +31,94 @@ 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
- * ```
+ *   ;```typescript
+ *   const nodes = [{ license: 'MIT' }, { license: 'GPL-3.0' }]
+ *   const incompatible = collectIncompatibleLicenses(nodes)
+ *   // incompatible contains only the GPL-3.0 node
+ *   ```
  */
 export declare function collectIncompatibleLicenses(licenseNodes: LicenseNode[]): LicenseNode[];
 /**
  * Collect warnings from license nodes.
  *
  * @example
- * ```typescript
- * const nodes = [{ license: 'UNLICENSED' }]
- * collectLicenseWarnings(nodes) // ['Package is unlicensed']
- * ```
+ *   ;```typescript
+ *   const nodes = [{ license: 'UNLICENSED' }]
+ *   collectLicenseWarnings(nodes) // ['Package is unlicensed']
+ *   ```
  */
 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'
- * ```
+ *   ;```typescript
+ *   const raw = { license: 'MIT' }
+ *   const node = createAstNode(raw)
+ *   // node.type === 'License'
+ *   ```
  */
 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'
- * ```
+ *   ;```typescript
+ *   const raw = {
+ *     left: { license: 'MIT' },
+ *     conjunction: 'OR' as const,
+ *     right: { license: 'Apache-2.0' },
+ *   }
+ *   const node = createBinaryOperationNode(raw)
+ *   // node.type === 'BinaryOperation'
+ *   ```
  */
 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'
- * ```
+ *   ;```typescript
+ *   const node = createLicenseNode({ license: 'MIT' })
+ *   // node.type === 'License' && node.license === 'MIT'
+ *   ```
  */
 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
- * ```
+ *   ;```typescript
+ *   const ast = parseSpdxExp('MIT OR Apache-2.0')
+ *   // ast is a BinaryOperation node with MIT and Apache-2.0 leaves
+ *   ```
  */
 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' }]
- * ```
+ *   ;```typescript
+ *   const nodes = resolvePackageLicenses('MIT', '/tmp/my-project')
+ *   // [{ license: 'MIT' }]
+ *   ```
  */
 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']
- * ```
+ *   ;```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']
+ *   ```
  */
 export declare function visitLicenses(ast: SpdxAstNode, visitor: LicenseVisitor): void;

package/dist/packages/licenses.js

@@ -40,22 +40,17 @@ __export(licenses_exports, {
   visitLicenses: () => visitLicenses
 });
 module.exports = __toCommonJS(licenses_exports);
-var import_core = require("../constants/core");
+var import_sentinels = require("../constants/sentinels");
 var import_licenses = require("../constants/licenses");
 var import_spdx_correct = __toESM(require("../external/spdx-correct"));
 var import_spdx_expression_parse = __toESM(require("../external/spdx-expression-parse"));
-var import_objects = require("../objects");
+var import_predicates = require("../objects/predicates");
 var import_normalize = require("../paths/normalize");
-var import_primordials = require("../primordials");
+var import_error = require("../primordials/error");
+var import_map_set = require("../primordials/map-set");
+var import_regexp = require("../primordials/regexp");
+var import_path = require("../node/path");
 const copyLeftLicenses = (0, import_licenses.getCopyLeftLicenses)();
-let _path;
-// @__NO_SIDE_EFFECTS__
-function getPath() {
-  if (_path === void 0) {
-    _path = require("node:path");
-  }
-  return _path;
-}
 const BINARY_OPERATION_NODE_TYPE = "BinaryOperation";
 const LICENSE_NODE_TYPE = "License";
 const fileReferenceRegExp = /^SEE LICEN[CS]E IN (.+)$/;
@@ -72,7 +67,7 @@ function collectIncompatibleLicenses(licenseNodes) {
 }
 // @__NO_SIDE_EFFECTS__
 function collectLicenseWarnings(licenseNodes) {
-  const warnings = new import_primordials.MapCtor();
+  const warnings = new import_map_set.MapCtor();
   for (let i = 0, { length } = licenseNodes; i < length; i += 1) {
     const node = licenseNodes[i];
     if (!node) {
@@ -89,7 +84,7 @@ function collectLicenseWarnings(licenseNodes) {
 }
 // @__NO_SIDE_EFFECTS__
 function createAstNode(rawNode) {
-  return (0, import_objects.hasOwn)(rawNode, "license") ? /* @__PURE__ */ createLicenseNode(rawNode) : /* @__PURE__ */ createBinaryOperationNode(rawNode);
+  return (0, import_predicates.hasOwn)(rawNode, "license") ? /* @__PURE__ */ createLicenseNode(rawNode) : /* @__PURE__ */ createBinaryOperationNode(rawNode);
 }
 // @__NO_SIDE_EFFECTS__
 function createBinaryOperationNode(rawNodeParam) {
@@ -140,9 +135,9 @@ function resolvePackageLicenses(licenseFieldValue, where) {
   if (licenseFieldValue === "UNLICENSED" || licenseFieldValue === "UNLICENCED") {
     return [{ license: "UNLICENSED" }];
   }
-  const match = (0, import_primordials.RegExpPrototypeExec)(fileReferenceRegExp, licenseFieldValue);
+  const match = (0, import_regexp.RegExpPrototypeExec)(fileReferenceRegExp, licenseFieldValue);
   if (match) {
-    const path = /* @__PURE__ */ getPath();
+    const path = (0, import_path.getNodePath)();
     return [
       {
         license: licenseFieldValue,
@@ -174,15 +169,15 @@ function visitLicenses(ast, visitor) {
   let pos = 0;
   let { length: queueLength } = queue;
   while (pos < queueLength) {
-    if (pos === import_core.LOOP_SENTINEL) {
-      throw new import_primordials.ErrorCtor(
+    if (pos === import_sentinels.LOOP_SENTINEL) {
+      throw new import_error.ErrorCtor(
         "Detected infinite loop in ast crawl of visitLicenses"
       );
     }
     const { 0: node, 1: parent } = queue[pos++];
     const { type } = node;
     const visitorRecord = visitor;
-    if (typeof visitorRecord[type] === "function" && (0, import_objects.hasOwn)(visitor, type)) {
+    if (typeof visitorRecord[type] === "function" && (0, import_predicates.hasOwn)(visitor, type)) {
       if (type === LICENSE_NODE_TYPE) {
         const licenseVisitor = visitorRecord["License"];
         if (typeof licenseVisitor === "function" && licenseVisitor(node, parent) === false) {