@socketsecurity/lib 5.26.0 → 5.26.1

package/dist/logger.js

@@ -94,7 +94,7 @@ const LOG_SYMBOLS = /* @__PURE__ */ (() => {
     }
     updateSymbols();
   };
-  for (const trapName of Reflect.ownKeys(Reflect)) {
+  for (const trapName of (0, import_primordials.ReflectOwnKeys)(Reflect)) {
     const fn = Reflect[trapName];
     if (typeof fn === "function") {
       ;
@@ -107,7 +107,7 @@ const LOG_SYMBOLS = /* @__PURE__ */ (() => {
   (0, import_context.onThemeChange)(() => {
     reset();
   });
-  return new Proxy(target, handler);
+  return new import_primordials.ProxyCtor(target, handler);
 })();
 const boundConsoleEntries = [
   // Add bound properties from console[kBindProperties](ignoreErrors, colorMode, groupIndentation).
@@ -146,8 +146,8 @@ const consolePropAttributes = {
   configurable: true
 };
 const maxIndentation = 1e3;
-const privateConsole = /* @__PURE__ */ new WeakMap();
-const privateConstructorArgs = /* @__PURE__ */ new WeakMap();
+const privateConsole = new import_primordials.WeakMapCtor();
+const privateConstructorArgs = new import_primordials.WeakMapCtor();
 const incLogCallCountSymbol = Symbol.for("logger.logCallCount++");
 const lastWasBlankSymbol = Symbol.for("logger.lastWasBlank");
 class Logger {
@@ -220,11 +220,14 @@ class Logger {
    */
   #apply(methodName, args, stream) {
     const con = this.#getConsole();
-    const text = args.at(0);
+    const text = (0, import_primordials.ArrayPrototypeAt)(args, 0);
     const hasText = typeof text === "string";
     const targetStream = stream || (methodName === "log" ? "stdout" : "stderr");
     const indent = this.#getIndent(targetStream);
-    const logArgs = hasText ? [(0, import_strings.applyLinePrefix)(text, { prefix: indent }), ...args.slice(1)] : args;
+    const logArgs = hasText ? [
+      (0, import_strings.applyLinePrefix)(text, { prefix: indent }),
+      ...(0, import_primordials.ArrayPrototypeSlice)(args, 1)
+    ] : args;
     (0, import_primordials.ReflectApply)(
       con[methodName],
       con,
@@ -350,7 +353,11 @@ class Logger {
    * @private
    */
   #stripSymbols(text) {
-    return text.replace(/^(?:[✖✗×⚠‼✔✓√ℹ→∴↻]|:.)[\uFE0F\s]*/u, "");
+    return (0, import_primordials.StringPrototypeReplace)(
+      text,
+      /^(?:[✖✗×⚠‼✔✓√ℹ→∴↻]|:.)[\uFE0F\s]*/u,
+      ""
+    );
   }
   /**
    * Apply a method with a symbol prefix.
@@ -358,11 +365,11 @@ class Logger {
    */
   #symbolApply(symbolType, args) {
     const con = this.#getConsole();
-    let text = args.at(0);
+    let text = (0, import_primordials.ArrayPrototypeAt)(args, 0);
     let extras;
     if (typeof text === "string") {
       text = this.#stripSymbols(text);
-      extras = args.slice(1);
+      extras = (0, import_primordials.ArrayPrototypeSlice)(args, 1);
     } else {
       extras = args;
       text = "";
@@ -587,7 +594,7 @@ class Logger {
    */
   clearVisible() {
     if (this.#boundStream) {
-      throw new Error(
+      throw new import_primordials.ErrorCtor(
         "clearVisible() is only available on the main logger instance, not on stream-bound instances"
       );
     }
@@ -932,7 +939,7 @@ class Logger {
    * ```
    */
   indent(spaces = 2) {
-    const spacesToAdd = " ".repeat(Math.min(spaces, maxIndentation));
+    const spacesToAdd = " ".repeat((0, import_primordials.MathMin)(spaces, maxIndentation));
     if (this.#boundStream) {
       const current = this.#getIndent(this.#boundStream);
       this.#setIndent(this.#boundStream, current + spacesToAdd);
@@ -1423,7 +1430,7 @@ function ensurePrototypeInitialized() {
       }
     ]
   ];
-  for (const { 0: key, 1: value } of Object.entries(globalConsole)) {
+  for (const { 0: key, 1: value } of (0, import_primordials.ObjectEntries)(globalConsole)) {
     if (!Logger.prototype[key] && typeof value === "function") {
       const { [key]: func } = {
         [key](...args) {
@@ -1457,11 +1464,11 @@ function ensurePrototypeInitialized() {
       ]);
     }
   }
-  Object.defineProperties(Logger.prototype, Object.fromEntries(entries));
+  (0, import_primordials.ObjectDefineProperties)(Logger.prototype, Object.fromEntries(entries));
 }
 function getConsoleSymbols() {
   if (_consoleSymbols === void 0) {
-    _consoleSymbols = Object.getOwnPropertySymbols(globalConsole);
+    _consoleSymbols = (0, import_primordials.ObjectGetOwnPropertySymbols)(globalConsole);
   }
   return _consoleSymbols;
 }

package/dist/memoization.js

@@ -29,9 +29,10 @@ __export(memoization_exports, {
 });
 module.exports = __toCommonJS(memoization_exports);
 var import_debug = require("./debug");
+var import_primordials = require("./primordials");
 const cacheRegistry = [];
 function defaultKeyGen(args) {
-  return JSON.stringify(args, (_key, value) => {
+  return (0, import_primordials.JSONStringify)(args, (_key, value) => {
     if (value === void 0) {
       return "\0undefined";
     }
@@ -74,9 +75,9 @@ function memoize(fn, options = {}) {
     ttl = Number.POSITIVE_INFINITY
   } = options;
   if (ttl < 0) {
-    throw new TypeError("TTL must be non-negative");
+    throw new import_primordials.TypeErrorCtor("TTL must be non-negative");
   }
-  const cache = /* @__PURE__ */ new Map();
+  const cache = new import_primordials.MapCtor();
   cacheRegistry.push(() => {
     cache.clear();
   });
@@ -96,7 +97,7 @@ function memoize(fn, options = {}) {
     if (ttl === Number.POSITIVE_INFINITY) {
       return false;
     }
-    return Date.now() - entry.timestamp > ttl;
+    return (0, import_primordials.DateNow)() - entry.timestamp > ttl;
   }
   return function memoized(...args) {
     const key = keyGen(...args);
@@ -130,7 +131,7 @@ function memoizeAsync(fn, options = {}) {
     name = fn.name || "anonymous",
     ttl = Number.POSITIVE_INFINITY
   } = options;
-  const cache = /* @__PURE__ */ new Map();
+  const cache = new import_primordials.MapCtor();
   cacheRegistry.push(() => {
     cache.clear();
   });
@@ -150,13 +151,13 @@ function memoizeAsync(fn, options = {}) {
     if (ttl === Number.POSITIVE_INFINITY) {
       return false;
     }
-    return Date.now() - entry.timestamp > ttl;
+    return (0, import_primordials.DateNow)() - entry.timestamp > ttl;
   }
   function bumpRecency(key, entry) {
     cache.delete(key);
     cache.set(key, entry);
   }
-  const refreshing = /* @__PURE__ */ new Map();
+  const refreshing = new import_primordials.MapCtor();
   return async function memoized(...args) {
     const key = keyGen(...args);
     const cached = cache.get(key);
@@ -176,23 +177,23 @@ function memoizeAsync(fn, options = {}) {
       cache.delete(key);
     }
     (0, import_debug.debugLog)(`[memoizeAsync:${name}] miss`, { key });
-    const promise = fn(...args).then(
-      (result) => {
+    const promise = (async () => {
+      try {
+        const result = await fn(...args);
         refreshing.delete(key);
         const entry = cache.get(key);
         if (entry) {
-          entry.value = Promise.resolve(result);
-          entry.timestamp = Date.now();
+          entry.value = (0, import_primordials.PromiseResolve)(result);
+          entry.timestamp = (0, import_primordials.DateNow)();
         }
         return result;
-      },
-      (error) => {
+      } catch (error) {
         refreshing.delete(key);
         cache.delete(key);
         (0, import_debug.debugLog)(`[memoizeAsync:${name}] error`, { key, error });
         throw error;
       }
-    );
+    })();
     refreshing.set(key, promise);
     evictLRU();
     cache.set(key, {
@@ -205,7 +206,7 @@ function memoizeAsync(fn, options = {}) {
   };
 }
 function memoizeWeak(fn) {
-  const cache = /* @__PURE__ */ new WeakMap();
+  const cache = new import_primordials.WeakMapCtor();
   return function memoized(key) {
     if (cache.has(key)) {
       (0, import_debug.debugLog)(`[memoizeWeak:${fn.name}] hit`);

package/dist/objects.js

@@ -66,7 +66,7 @@ function createConstantsObject(props, options_) {
   });
   const lazyGetterStats = (0, import_primordials.ObjectFreeze)({
     __proto__: null,
-    initialized: /* @__PURE__ */ new Set()
+    initialized: new import_primordials.SetCtor()
   });
   const object = defineLazyGetters(
     {
@@ -207,7 +207,7 @@ function merge(target, source) {
   let { length: queueLength } = queue;
   while (pos < queueLength) {
     if (pos === import_core.LOOP_SENTINEL) {
-      throw new Error("Detected infinite loop in object crawl of merge");
+      throw new import_primordials.ErrorCtor("Detected infinite loop in object crawl of merge");
     }
     const { 0: currentTarget, 1: currentSource } = queue[pos++];
     if (!currentSource || !currentTarget) {

package/dist/packages/edit.js

@@ -43,6 +43,7 @@ var import_format = require("../json/format");
 var import_normalize = require("../paths/normalize");
 var import_normalize2 = require("./normalize");
 var import_packages = require("../paths/packages");
+var import_primordials = require("../primordials");
 let _EditablePackageJsonClass;
 let _fs;
 // @__NO_SIDE_EFFECTS__
@@ -87,7 +88,7 @@ function getEditablePackageJsonClass() {
         if (!path) {
           return "";
         }
-        if (path.endsWith("package.json")) {
+        if ((0, import_primordials.StringPrototypeEndsWith)(path, "package.json")) {
           return path;
         }
         const nodePath = /* @__PURE__ */ getPath();
@@ -191,7 +192,7 @@ function getEditablePackageJsonClass() {
       }
       async save(options) {
         if (!this._canSave || this.content === void 0) {
-          throw new Error("No package.json to save to");
+          throw new import_primordials.ErrorCtor("No package.json to save to");
         }
         if (!(0, import_format.shouldSave)(
           this.content,
@@ -217,7 +218,7 @@ function getEditablePackageJsonClass() {
       }
       saveSync(options) {
         if (!this._canSave || this.content === void 0) {
-          throw new Error("No package.json to save to");
+          throw new import_primordials.ErrorCtor("No package.json to save to");
         }
         const { ignoreWhitespace = false, sort = false } = {
           __proto__: null,
@@ -234,7 +235,7 @@ function getEditablePackageJsonClass() {
         }
         const format = indent === void 0 || indent === null ? "  " : indent;
         const eol = newline === void 0 || newline === null ? "\n" : newline;
-        const fileContent = `${JSON.stringify(
+        const fileContent = `${(0, import_primordials.JSONStringify)(
           content,
           void 0,
           format
@@ -272,7 +273,7 @@ function getEditablePackageJsonClass() {
         }
         const format = indent === void 0 || indent === null ? "  " : indent;
         const eol = newline === void 0 || newline === null ? "\n" : newline;
-        const fileContent = `${JSON.stringify(
+        const fileContent = `${(0, import_primordials.JSONStringify)(
           content,
           void 0,
           format
@@ -311,7 +312,7 @@ async function toEditablePackageJson(pkgJson, options) {
   const EditablePackageJson = /* @__PURE__ */ getEditablePackageJsonClass();
   const pkgJsonPath = (0, import_packages.resolvePackageJsonDirname)(filepath);
   return (await EditablePackageJson.load(pkgJsonPath, { create: true })).fromJSON(
-    `${JSON.stringify(
+    `${(0, import_primordials.JSONStringify)(
       normalize ? (0, import_normalize2.normalizePackageJson)(pkgJson, {
         ...(0, import_normalize.isNodeModules)(pkgJsonPath) ? {} : { preserve: ["repository"] },
         ...normalizeOptions
@@ -335,7 +336,7 @@ function toEditablePackageJsonSync(pkgJson, options) {
   const EditablePackageJson = /* @__PURE__ */ getEditablePackageJsonClass();
   const pkgJsonPath = (0, import_packages.resolvePackageJsonDirname)(filepath);
   return new EditablePackageJson().create(pkgJsonPath).fromJSON(
-    `${JSON.stringify(
+    `${(0, import_primordials.JSONStringify)(
       normalize ? (0, import_normalize2.normalizePackageJson)(pkgJson, {
         ...(0, import_normalize.isNodeModules)(pkgJsonPath) ? {} : { preserve: ["repository"] },
         ...normalizeOptions

package/dist/packages/exports.js

@@ -31,13 +31,14 @@ 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");
 // @__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 Error(
+      throw new import_primordials.ErrorCtor(
         "Detected infinite loop in entry exports crawl of getTypesForSubpath"
       );
     }
@@ -53,7 +54,7 @@ function findTypesForSubpath(entryExports, subpath) {
         }
       }
     } else if ((0, import_objects.isObject)(value)) {
-      const keys = Object.getOwnPropertyNames(value);
+      const keys = (0, import_primordials.ObjectGetOwnPropertyNames)(value);
       for (let i = 0, { length } = keys; i < length; i += 1) {
         const key = keys[i];
         const item = value[key];
@@ -74,27 +75,27 @@ function getExportFilePaths(entryExports) {
     return [];
   }
   const paths = [];
-  for (const key of Object.getOwnPropertyNames(entryExports)) {
-    if (!key.startsWith(".")) {
+  for (const key of (0, import_primordials.ObjectGetOwnPropertyNames)(entryExports)) {
+    if (!(0, import_primordials.StringPrototypeStartsWith)(key, ".")) {
       continue;
     }
     const value = entryExports[key];
     if (typeof value === "string") {
-      paths.push(value);
+      (0, import_primordials.ArrayPrototypePush)(paths, value);
     } else if ((0, import_objects.isObject)(value)) {
-      for (const subKey of Object.getOwnPropertyNames(value)) {
+      for (const subKey of (0, import_primordials.ObjectGetOwnPropertyNames)(value)) {
         const subValue = value[subKey];
         if (typeof subValue === "string") {
-          paths.push(subValue);
+          (0, import_primordials.ArrayPrototypePush)(paths, subValue);
         } else if ((0, import_arrays.isArray)(subValue)) {
           for (const item of subValue) {
             if (typeof item === "string") {
-              paths.push(item);
+              (0, import_primordials.ArrayPrototypePush)(paths, item);
             } else if ((0, import_objects.isObject)(item)) {
-              for (const nestedKey of Object.getOwnPropertyNames(item)) {
+              for (const nestedKey of (0, import_primordials.ObjectGetOwnPropertyNames)(item)) {
                 const nestedValue = item[nestedKey];
                 if (typeof nestedValue === "string") {
-                  paths.push(nestedValue);
+                  (0, import_primordials.ArrayPrototypePush)(paths, nestedValue);
                 }
               }
             }
@@ -103,15 +104,15 @@ function getExportFilePaths(entryExports) {
       }
     }
   }
-  return [...new Set(paths)].filter((p) => p.startsWith("./"));
+  return [...new import_primordials.SetCtor(paths)].filter((p) => (0, import_primordials.StringPrototypeStartsWith)(p, "./"));
 }
 // @__NO_SIDE_EFFECTS__
 function getSubpaths(entryExports) {
   if (!(0, import_objects.isObject)(entryExports)) {
     return [];
   }
-  return Object.getOwnPropertyNames(entryExports).filter(
-    (key) => key.startsWith(".")
+  return (0, import_primordials.ObjectGetOwnPropertyNames)(entryExports).filter(
+    (key) => (0, import_primordials.StringPrototypeStartsWith)(key, ".")
   );
 }
 // @__NO_SIDE_EFFECTS__
@@ -119,14 +120,14 @@ function isConditionalExports(entryExports) {
   if (!(0, import_objects.isObjectObject)(entryExports)) {
     return false;
   }
-  const keys = Object.getOwnPropertyNames(entryExports);
+  const keys = (0, import_primordials.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 && key.charCodeAt(0) === 46) {
+    if (key.length > 0 && (0, import_primordials.StringPrototypeCharCodeAt)(key, 0) === 46) {
       return false;
     }
   }
@@ -135,7 +136,7 @@ function isConditionalExports(entryExports) {
 // @__NO_SIDE_EFFECTS__
 function isSubpathExports(entryExports) {
   if ((0, import_objects.isObjectObject)(entryExports)) {
-    const keys = Object.getOwnPropertyNames(entryExports);
+    const keys = (0, import_primordials.ObjectGetOwnPropertyNames)(entryExports);
     for (let i = 0, { length } = keys; i < length; i += 1) {
       if (keys[i]?.charCodeAt(0) === 46) {
         return true;

package/dist/packages/isolation.js

@@ -40,10 +40,11 @@ var import_normalize = require("../paths/normalize");
 var import_socket = require("../paths/socket");
 var import_spawn = require("../spawn");
 var import_operations = require("./operations");
+var import_primordials = require("../primordials");
 const FS_CP_OPTIONS = {
   dereference: true,
   errorOnExist: false,
-  filter: (src) => !src.includes("node_modules") && !src.endsWith(".DS_Store"),
+  filter: (src) => !src.includes("node_modules") && !(0, import_primordials.StringPrototypeEndsWith)(src, ".DS_Store"),
   force: true,
   recursive: true,
   ...import_platform.WIN32 ? { maxRetries: 3, retryDelay: 100 } : {}
@@ -68,9 +69,9 @@ async function mergePackageJson(pkgJsonPath, originalPkgJson) {
   const fs = /* @__PURE__ */ getFs();
   let pkgJson;
   try {
-    pkgJson = JSON.parse(await fs.promises.readFile(pkgJsonPath, "utf8"));
+    pkgJson = (0, import_primordials.JSONParse)(await fs.promises.readFile(pkgJsonPath, "utf8"));
   } catch (e) {
-    throw new Error(`Failed to parse ${pkgJsonPath}: ${(0, import_errors.errorMessage)(e)}`, {
+    throw new import_primordials.ErrorCtor(`Failed to parse ${pkgJsonPath}: ${(0, import_errors.errorMessage)(e)}`, {
       cause: e
     });
   }
@@ -80,7 +81,11 @@ async function mergePackageJson(pkgJsonPath, originalPkgJson) {
 async function resolveRealPath(pathStr) {
   const fs = /* @__PURE__ */ getFs();
   const path = /* @__PURE__ */ getPath();
-  return await fs.promises.realpath(pathStr).catch(() => path.resolve(pathStr));
+  try {
+    return await fs.promises.realpath(pathStr);
+  } catch {
+    return path.resolve(pathStr);
+  }
 }
 async function isolatePackage(packageSpec, options) {
   const fs = /* @__PURE__ */ getFs();
@@ -95,11 +100,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 Error(`Source path does not exist: ${sourcePath}`);
+      throw new import_primordials.ErrorCtor(`Source path does not exist: ${sourcePath}`);
     }
     const pkgJson = await (0, import_operations.readPackageJson)(sourcePath, { normalize: true });
     if (!pkgJson) {
-      throw new Error(`Could not read package.json from: ${sourcePath}`);
+      throw new import_primordials.ErrorCtor(`Could not read package.json from: ${sourcePath}`);
     }
     packageName = pkgJson.name;
   } else {
@@ -108,12 +113,12 @@ async function isolatePackage(packageSpec, options) {
     if (parsed.type === "directory" || parsed.type === "file") {
       sourcePath = parsed.fetchSpec;
       if (!sourcePath || !fs.existsSync(sourcePath)) {
-        throw new Error(`Source path does not exist: ${sourcePath}`);
+        throw new import_primordials.ErrorCtor(`Source path does not exist: ${sourcePath}`);
       }
       if (!packageName) {
         const pkgJson = await (0, import_operations.readPackageJson)(sourcePath, { normalize: true });
         if (!pkgJson) {
-          throw new Error(`Could not read package.json from: ${sourcePath}`);
+          throw new import_primordials.ErrorCtor(`Could not read package.json from: ${sourcePath}`);
         }
         packageName = pkgJson.name;
       }
@@ -122,7 +127,7 @@ async function isolatePackage(packageSpec, options) {
     }
   }
   if (!packageName) {
-    throw new Error(`Could not determine package name from: ${packageSpec}`);
+    throw new import_primordials.ErrorCtor(`Could not determine package name from: ${packageSpec}`);
   }
   const sanitizedName = packageName.replace(/[@/]/g, "-");
   const tempDir = await fs.promises.mkdtemp(
@@ -148,7 +153,7 @@ async function isolatePackage(packageSpec, options) {
     if (install) {
       await install(packageTempDir);
     } else {
-      const packageInstallSpec = spec.startsWith("https://") ? spec : `${packageName}@${spec}`;
+      const packageInstallSpec = (0, import_primordials.StringPrototypeStartsWith)(spec, "https://") ? spec : `${packageName}@${spec}`;
       await (0, import_spawn.spawn)("pnpm", ["add", packageInstallSpec], {
         cwd: packageTempDir,
         shell: import_platform.WIN32,
@@ -168,9 +173,11 @@ async function isolatePackage(packageSpec, options) {
     }
   } else {
     if (!sourcePath) {
-      throw new Error("sourcePath is required when no version spec provided");
+      throw new import_primordials.ErrorCtor(
+        "sourcePath is required when no version spec provided"
+      );
     }
-    const scopedPath = packageName.startsWith("@") ? path.join(
+    const scopedPath = (0, import_primordials.StringPrototypeStartsWith)(packageName, "@") ? path.join(
       packageTempDir,
       "node_modules",
       packageName.split("/")[0] ?? ""
@@ -202,7 +209,7 @@ async function isolatePackage(packageSpec, options) {
   }
   const exports2 = imports ? { __proto__: null } : void 0;
   if (imports) {
-    for (const { 0: key, 1: specifier } of Object.entries(imports)) {
+    for (const { 0: key, 1: specifier } of (0, import_primordials.ObjectEntries)(imports)) {
       const fullPath = path.join(installedPath, specifier);
       exports2[key] = require(fullPath);
     }

package/dist/packages/licenses.js

@@ -46,6 +46,7 @@ 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_normalize = require("../paths/normalize");
+var import_primordials = require("../primordials");
 const copyLeftLicenses = (0, import_licenses.getCopyLeftLicenses)();
 let _path;
 // @__NO_SIDE_EFFECTS__
@@ -71,7 +72,7 @@ function collectIncompatibleLicenses(licenseNodes) {
 }
 // @__NO_SIDE_EFFECTS__
 function collectLicenseWarnings(licenseNodes) {
-  const warnings = /* @__PURE__ */ new Map();
+  const warnings = new import_primordials.MapCtor();
   for (let i = 0, { length } = licenseNodes; i < length; i += 1) {
     const node = licenseNodes[i];
     if (!node) {
@@ -139,7 +140,7 @@ function resolvePackageLicenses(licenseFieldValue, where) {
   if (licenseFieldValue === "UNLICENSED" || licenseFieldValue === "UNLICENCED") {
     return [{ license: "UNLICENSED" }];
   }
-  const match = fileReferenceRegExp.exec(licenseFieldValue);
+  const match = (0, import_primordials.RegExpPrototypeExec)(fileReferenceRegExp, licenseFieldValue);
   if (match) {
     const path = /* @__PURE__ */ getPath();
     return [
@@ -174,7 +175,9 @@ function visitLicenses(ast, visitor) {
   let { length: queueLength } = queue;
   while (pos < queueLength) {
     if (pos === import_core.LOOP_SENTINEL) {
-      throw new Error("Detected infinite loop in ast crawl of visitLicenses");
+      throw new import_primordials.ErrorCtor(
+        "Detected infinite loop in ast crawl of visitLicenses"
+      );
     }
     const { 0: node, 1: parent } = queue[pos++];
     const { type } = node;

package/dist/packages/manifest.js

@@ -45,6 +45,7 @@ var import_arrays = require("../arrays");
 var import_objects = require("../objects");
 var import_exports = require("./exports");
 var import_validation = require("./validation");
+var import_primordials = require("../primordials");
 const abortSignal = (0, import_process.getAbortSignal)();
 const packageDefaultNodeRange = (0, import_packages.getPackageDefaultNodeRange)();
 const PACKAGE_DEFAULT_SOCKET_CATEGORIES = (0, import_packages.getPackageDefaultSocketCategories)();
@@ -91,7 +92,7 @@ function createPackageJson(sockRegPkgName, directory, options) {
     ...(0, import_objects.isObjectObject)(overrides) ? { overrides: { ...overrides } } : {},
     ...(0, import_objects.isObjectObject)(resolutions) ? { resolutions: { ...resolutions } } : {},
     ...(0, import_objects.isObjectObject)(engines) ? {
-      engines: Object.fromEntries(
+      engines: (0, import_primordials.ObjectFromEntries)(
         (0, import_objects.objectEntries)(engines).map((pair) => {
           const strKey = String(pair[0]);
           const result = [strKey, pair[1]];

package/dist/packages/normalize.js

@@ -41,11 +41,12 @@ var import_regexps = require("../regexps");
 var import_normalize_package_data = __toESM(require("../external/normalize-package-data"));
 var import_objects = require("../objects");
 var import_operations = require("./operations");
+var import_primordials = require("../primordials");
 const ArrayIsArray = Array.isArray;
 const ObjectHasOwn = Object.hasOwn;
 function getEscapedScopeRegExp() {
   const firstChar = import_socket.REGISTRY_SCOPE_DELIMITER[0];
-  return new RegExp(
+  return new import_primordials.RegExpCtor(
     `^[^${(0, import_regexps.escapeRegExp)(firstChar)}]+${(0, import_regexps.escapeRegExp)(import_socket.REGISTRY_SCOPE_DELIMITER)}(?!${(0, import_regexps.escapeRegExp)(firstChar)})`
   );
 }
@@ -81,14 +82,17 @@ function normalizePackageJson(pkgJson, options) {
 // @__NO_SIDE_EFFECTS__
 function resolveEscapedScope(sockRegPkgName) {
   const escapedScopeRegExp = getEscapedScopeRegExp();
-  const match = escapedScopeRegExp.exec(sockRegPkgName)?.[0];
+  const match = (0, import_primordials.RegExpPrototypeExec)(escapedScopeRegExp, sockRegPkgName)?.[0];
   return match || void 0;
 }
 // @__NO_SIDE_EFFECTS__
 function resolveOriginalPackageName(sockRegPkgName) {
-  const name = sockRegPkgName.startsWith(`${import_socket.SOCKET_REGISTRY_SCOPE}/`) ? sockRegPkgName.slice(import_socket.SOCKET_REGISTRY_SCOPE.length + 1) : sockRegPkgName;
+  const name = (0, import_primordials.StringPrototypeStartsWith)(
+    sockRegPkgName,
+    `${import_socket.SOCKET_REGISTRY_SCOPE}/`
+  ) ? sockRegPkgName.slice(import_socket.SOCKET_REGISTRY_SCOPE.length + 1) : sockRegPkgName;
   const escapedScope = /* @__PURE__ */ resolveEscapedScope(name);
-  return escapedScope ? `${/* @__PURE__ */ unescapeScope(escapedScope)}/${name.slice(escapedScope.length)}` : name;
+  return escapedScope ? `${/* @__PURE__ */ unescapeScope(escapedScope)}/${(0, import_primordials.StringPrototypeSlice)(name, escapedScope.length)}` : name;
 }
 // @__NO_SIDE_EFFECTS__
 function unescapeScope(escapedScope) {

package/dist/packages/operations.js

@@ -57,6 +57,7 @@ var import_normalize = require("./normalize");
 var import_packages2 = require("../paths/packages");
 var import_specs = require("./specs");
 var import_edit = require("./edit");
+var import_primordials = require("../primordials");
 const abortSignal = (0, import_process.getAbortSignal)();
 const packageExtensions = (0, import_packages.getPackageExtensions)();
 const packumentCache = (0, import_packages.getPackumentCache)();
@@ -131,13 +132,13 @@ function getReleaseTag(spec) {
     return "";
   }
   let atIndex = -1;
-  if (spec.startsWith("@")) {
-    atIndex = spec.indexOf("@", 1);
+  if ((0, import_primordials.StringPrototypeStartsWith)(spec, "@")) {
+    atIndex = (0, import_primordials.StringPrototypeIndexOf)(spec, "@", 1);
   } else {
-    atIndex = spec.indexOf("@");
+    atIndex = (0, import_primordials.StringPrototypeIndexOf)(spec, "@");
   }
   if (atIndex !== -1) {
-    return spec.slice(atIndex + 1);
+    return (0, import_primordials.StringPrototypeSlice)(spec, atIndex + 1);
   }
   return "";
 }