@socketsecurity/lib 5.25.1 → 5.26.1

package/dist/cache-with-ttl.js

@@ -34,6 +34,7 @@ __export(cache_with_ttl_exports, {
 });
 module.exports = __toCommonJS(cache_with_ttl_exports);
 var cacache = __toESM(require("./cacache"));
+var import_primordials = require("./primordials");
 const DEFAULT_TTL_MS = 5 * 60 * 1e3;
 const DEFAULT_PREFIX = "ttl-cache";
 const DEFAULT_MEMO_MAX_SIZE = 1e3;
@@ -47,12 +48,12 @@ function createTtlCache(options) {
     ...options
   };
   if (opts.prefix?.includes("*")) {
-    throw new TypeError(
+    throw new import_primordials.TypeErrorCtor(
       'Cache prefix cannot contain wildcards (*). Use clear({ prefix: "pattern*" }) for wildcard matching.'
     );
   }
-  const memoCache = /* @__PURE__ */ new Map();
-  const memoMaxSize = Math.max(1, opts.memoMaxSize ?? DEFAULT_MEMO_MAX_SIZE);
+  const memoCache = new import_primordials.MapCtor();
+  const memoMaxSize = (0, import_primordials.MathMax)(1, opts.memoMaxSize ?? DEFAULT_MEMO_MAX_SIZE);
   function memoSet(fullKey, entry) {
     if (memoCache.has(fullKey)) {
       memoCache.delete(fullKey);
@@ -69,7 +70,7 @@ function createTtlCache(options) {
     return `${opts.prefix}:${key}`;
   }
   function isExpired(entry) {
-    const now = Date.now();
+    const now = (0, import_primordials.DateNow)();
     const maxFutureMs = 1e4;
     if (entry.expiresAt > now + ttl + maxFutureMs) {
       return true;
@@ -80,16 +81,20 @@ function createTtlCache(options) {
     const fullPattern = buildKey(pattern);
     const hasWildcard = pattern.includes("*");
     if (!hasWildcard) {
-      return (key) => key.startsWith(fullPattern);
+      return (key) => (0, import_primordials.StringPrototypeStartsWith)(key, fullPattern);
     }
-    const escaped = fullPattern.replaceAll(/[.+?^${}()|[\]\\]/g, "\\$&");
-    const regexPattern = escaped.replaceAll("*", ".*");
-    const regex = new RegExp(`^${regexPattern}$`);
-    return (key) => regex.test(key);
+    const escaped = (0, import_primordials.StringPrototypeReplaceAll)(
+      fullPattern,
+      /[.+?^${}()|[\]\\]/g,
+      "\\$&"
+    );
+    const regexPattern = (0, import_primordials.StringPrototypeReplaceAll)(escaped, "*", ".*");
+    const regex = new import_primordials.RegExpCtor(`^${regexPattern}$`);
+    return (key) => (0, import_primordials.RegExpPrototypeTest)(regex, key);
   }
   async function get(key) {
-    if (key.includes("*")) {
-      throw new TypeError(
+    if ((0, import_primordials.StringPrototypeIncludes)(key, "*")) {
+      throw new import_primordials.TypeErrorCtor(
         "Cache key cannot contain wildcards (*). Use getAll(pattern) to retrieve multiple entries."
       );
     }
@@ -108,7 +113,7 @@ function createTtlCache(options) {
     if (cacheEntry) {
       let entry;
       try {
-        entry = JSON.parse(cacheEntry.data.toString("utf8"));
+        entry = (0, import_primordials.JSONParse)(cacheEntry.data.toString("utf8"));
       } catch {
         try {
           await cacache.remove(fullKey);
@@ -130,7 +135,7 @@ function createTtlCache(options) {
     return void 0;
   }
   async function getAll(pattern) {
-    const results = /* @__PURE__ */ new Map();
+    const results = new import_primordials.MapCtor();
     const matches = createMatcher(pattern);
     if (opts.memoize) {
       for (const [key, entry] of memoCache.entries()) {
@@ -141,7 +146,7 @@ function createTtlCache(options) {
           memoCache.delete(key);
           continue;
         }
-        const originalKey = opts.prefix ? key.slice(opts.prefix.length + 1) : key;
+        const originalKey = opts.prefix ? (0, import_primordials.StringPrototypeSlice)(key, opts.prefix.length + 1) : key;
         results.set(originalKey, entry.data);
       }
     }
@@ -164,7 +169,7 @@ function createTtlCache(options) {
         if (!entry) {
           continue;
         }
-        const parsed = JSON.parse(
+        const parsed = (0, import_primordials.JSONParse)(
           entry.data.toString("utf8")
         );
         if (isExpired(parsed)) {
@@ -181,15 +186,15 @@ function createTtlCache(options) {
     return results;
   }
   async function set(key, data) {
-    if (key.includes("*")) {
-      throw new TypeError(
+    if ((0, import_primordials.StringPrototypeIncludes)(key, "*")) {
+      throw new import_primordials.TypeErrorCtor(
         'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: "pattern*" }).'
       );
     }
     const fullKey = buildKey(key);
     const entry = {
       data,
-      expiresAt: Date.now() + ttl
+      expiresAt: (0, import_primordials.DateNow)() + ttl
     };
     if (opts.memoize) {
       memoSet(fullKey, entry);
@@ -201,7 +206,7 @@ function createTtlCache(options) {
     } catch {
     }
   }
-  const inflightRequests = /* @__PURE__ */ new Map();
+  const inflightRequests = new import_primordials.MapCtor();
   async function getOrFetch(key, fetcher) {
     const fullKey = buildKey(key);
     const preexisting = inflightRequests.get(fullKey);
@@ -229,8 +234,8 @@ function createTtlCache(options) {
     return await promise;
   }
   async function deleteEntry(key) {
-    if (key.includes("*")) {
-      throw new TypeError(
+    if ((0, import_primordials.StringPrototypeIncludes)(key, "*")) {
+      throw new import_primordials.TypeErrorCtor(
         "Cache key cannot contain wildcards (*). Use deleteAll(pattern) to remove multiple entries."
       );
     }

package/dist/colors.js

@@ -24,6 +24,7 @@ __export(colors_exports, {
   toRgb: () => toRgb
 });
 module.exports = __toCommonJS(colors_exports);
+var import_primordials = require("./primordials");
 const colorToRgb = {
   __proto__: null,
   black: [0, 0, 0],
@@ -44,7 +45,7 @@ const colorToRgb = {
   yellowBright: [255, 255, 153]
 };
 function isRgbTuple(value) {
-  return Array.isArray(value);
+  return (0, import_primordials.ArrayIsArray)(value);
 }
 function toRgb(color) {
   if (isRgbTuple(color)) {

package/dist/constants/licenses.js

@@ -26,13 +26,14 @@ __export(licenses_exports, {
   getCopyLeftLicenses: () => getCopyLeftLicenses
 });
 module.exports = __toCommonJS(licenses_exports);
+var import_primordials = require("../primordials");
 const MIT = "MIT";
 const UNLICENCED = "UNLICENCED";
 const UNLICENSED = "UNLICENSED";
 let _copyLeftLicenses;
 function getCopyLeftLicenses() {
   if (_copyLeftLicenses === void 0) {
-    _copyLeftLicenses = /* @__PURE__ */ new Set([
+    _copyLeftLicenses = new import_primordials.SetCtor([
       "AGPL-1.0",
       "AGPL-1.0-only",
       "AGPL-1.0-or-later",

package/dist/constants/lifecycle-script-names.js

@@ -23,7 +23,8 @@ __export(lifecycle_script_names_exports, {
   lifecycleScriptNames: () => lifecycleScriptNames
 });
 module.exports = __toCommonJS(lifecycle_script_names_exports);
-const lifecycleScriptNames = new Set(
+var import_primordials = require("../primordials");
+const lifecycleScriptNames = new import_primordials.SetCtor(
   [
     "dependencies",
     "prepublishOnly",

package/dist/constants/maintained-node-versions.js

@@ -23,13 +23,14 @@ __export(maintained_node_versions_exports, {
   maintainedNodeVersions: () => maintainedNodeVersions
 });
 module.exports = __toCommonJS(maintained_node_versions_exports);
+var import_primordials = require("../primordials");
 const ObjectFreeze = Object.freeze;
 const next = "25.0.0";
 const current = "22.20.0";
 const previous = "20.19.5";
 const last = "18.20.8";
 const maintainedNodeVersions = ObjectFreeze(
-  Object.assign([last, previous, current, next], {
+  (0, import_primordials.ObjectAssign)([last, previous, current, next], {
     current,
     last,
     next,

package/dist/constants/node.js

@@ -54,6 +54,7 @@ __export(node_exports, {
 module.exports = __toCommonJS(node_exports);
 var import_node_process = __toESM(require("node:process"));
 var import_maintained_node_versions = require("./maintained-node-versions");
+var import_primordials = require("../primordials");
 const NODE_VERSION = import_node_process.default.version;
 let _nodeDisableSigusr1Flags;
 let _nodeHardenFlags;
@@ -90,10 +91,10 @@ function getNodeHardenFlags() {
 }
 function getNodeMajorVersion() {
   const major = NODE_VERSION.slice(1).split(".")[0] ?? "0";
-  return Number.parseInt(major, 10) || 0;
+  return (0, import_primordials.NumberParseInt)(major, 10) || 0;
 }
 function getNodeMinorVersion() {
-  return Number.parseInt(NODE_VERSION.split(".")[1] ?? "0", 10);
+  return (0, import_primordials.NumberParseInt)(NODE_VERSION.split(".")[1] ?? "0", 10);
 }
 function getNodeNoWarningsFlags() {
   if (_nodeNoWarningsFlags === void 0) {
@@ -102,7 +103,7 @@ function getNodeNoWarningsFlags() {
   return _nodeNoWarningsFlags;
 }
 function getNodePatchVersion() {
-  return Number.parseInt(NODE_VERSION.split(".")[2] ?? "0", 10);
+  return (0, import_primordials.NumberParseInt)(NODE_VERSION.split(".")[2] ?? "0", 10);
 }
 function getNodePermissionFlags() {
   if (_nodePermissionFlags === void 0) {

package/dist/constants/package-default-socket-categories.js

@@ -23,7 +23,8 @@ __export(package_default_socket_categories_exports, {
   packageDefaultSocketCategories: () => packageDefaultSocketCategories
 });
 module.exports = __toCommonJS(package_default_socket_categories_exports);
-const packageDefaultSocketCategories = Object.freeze(["cleanup"]);
+var import_primordials = require("../primordials");
+const packageDefaultSocketCategories = (0, import_primordials.ObjectFreeze)(["cleanup"]);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   packageDefaultSocketCategories

package/dist/constants/packages.js

@@ -49,6 +49,7 @@ var import_normalize = require("../paths/normalize");
 var import_lifecycle_script_names = require("./lifecycle-script-names");
 var import_package_default_node_range = require("./package-default-node-range");
 var import_package_default_socket_categories = require("./package-default-socket-categories");
+var import_primordials = require("../primordials");
 let _lifecycleScriptNames;
 let _packageDefaultNodeRange;
 let _packageDefaultSocketCategories;
@@ -67,7 +68,7 @@ function clearPackumentCache() {
 // @__NO_SIDE_EFFECTS__
 function getLifecycleScriptNames() {
   if (_lifecycleScriptNames === void 0) {
-    _lifecycleScriptNames = Array.from(import_lifecycle_script_names.lifecycleScriptNames);
+    _lifecycleScriptNames = (0, import_primordials.ArrayFrom)(import_lifecycle_script_names.lifecycleScriptNames);
   }
   return _lifecycleScriptNames;
 }
@@ -88,7 +89,7 @@ function getPackageDefaultSocketCategories() {
 // @__NO_SIDE_EFFECTS__
 function getPackageExtensions() {
   if (_packageExtensions === void 0) {
-    _packageExtensions = Object.entries(import_package_extensions.packageExtensions);
+    _packageExtensions = (0, import_primordials.ObjectEntries)(import_package_extensions.packageExtensions);
   }
   return _packageExtensions;
 }
@@ -117,7 +118,7 @@ function getPackumentCache() {
 function getPacoteCachePath() {
   if (_pacoteCachePath === void 0) {
     try {
-      const proto = Reflect.getPrototypeOf(
+      const proto = (0, import_primordials.ReflectGetPrototypeOf)(
         import_pacote.default.RegistryFetcher.prototype
       );
       const PacoteFetcherBase = proto?.constructor;

package/dist/constants/socket.js

@@ -77,7 +77,7 @@ const SOCKET_FIREWALL_APP_NAME = "sfw";
 const SOCKET_REGISTRY_APP_NAME = "registry";
 const SOCKET_APP_PREFIX = "_";
 const SOCKET_LIB_NAME = "@socketsecurity/lib";
-const SOCKET_LIB_VERSION = "5.25.1";
+const SOCKET_LIB_VERSION = "5.26.1";
 const SOCKET_LIB_URL = "https://github.com/SocketDev/socket-lib";
 const SOCKET_LIB_USER_AGENT = `socketsecurity-lib/${SOCKET_LIB_VERSION} (${SOCKET_LIB_URL})`;
 const SOCKET_IPC_HANDSHAKE = "SOCKET_IPC_HANDSHAKE";

package/dist/cover/code.js

@@ -37,6 +37,7 @@ var import_node_process = __toESM(require("node:process"));
 var import_fs = require("../fs");
 var import_objects = require("../objects");
 var import_spawn = require("../spawn");
+var import_primordials = require("../primordials");
 let _fs;
 let _path;
 function calculateMetric(data) {
@@ -71,7 +72,7 @@ async function getCodeCoverage(options) {
   };
   const { coveragePath, generateIfMissing } = opts;
   if (!coveragePath) {
-    throw new Error("Coverage path is required");
+    throw new import_primordials.ErrorCtor("Coverage path is required");
   }
   const fs = /* @__PURE__ */ getFs();
   if (!fs.existsSync(coveragePath)) {
@@ -81,14 +82,14 @@ async function getCodeCoverage(options) {
         stdio: "inherit"
       });
     } else {
-      throw new Error(
+      throw new import_primordials.ErrorCtor(
         `Coverage file not found at "${coveragePath}". Run tests with coverage first.`
       );
     }
   }
   const coverageData = await (0, import_fs.readJson)(coveragePath);
   if (!(0, import_objects.isObjectObject)(coverageData)) {
-    throw new Error(`Invalid coverage data format in "${coveragePath}"`);
+    throw new import_primordials.ErrorCtor(`Invalid coverage data format in "${coveragePath}"`);
   }
   const totals = {
     __proto__: null,
@@ -98,13 +99,13 @@ async function getCodeCoverage(options) {
     statements: { __proto__: null, covered: 0, total: 0 }
   };
   const v8Data = coverageData;
-  for (const fileCoverage of Object.values(v8Data)) {
+  for (const fileCoverage of (0, import_primordials.ObjectValues)(v8Data)) {
     if (!(0, import_objects.isObjectObject)(fileCoverage)) {
       continue;
     }
     const fc = fileCoverage;
     if (fc.s && (0, import_objects.isObjectObject)(fc.s)) {
-      const statementCounts = Object.values(fc.s);
+      const statementCounts = (0, import_primordials.ObjectValues)(fc.s);
       for (const count of statementCounts) {
         if (typeof count === "number") {
           totals.statements.total += 1;
@@ -115,9 +116,9 @@ async function getCodeCoverage(options) {
       }
     }
     if (fc.b && (0, import_objects.isObjectObject)(fc.b)) {
-      const branchCounts = Object.values(fc.b);
+      const branchCounts = (0, import_primordials.ObjectValues)(fc.b);
       for (const branches of branchCounts) {
-        if (Array.isArray(branches)) {
+        if ((0, import_primordials.ArrayIsArray)(branches)) {
           for (const count of branches) {
             if (typeof count === "number") {
               totals.branches.total += 1;
@@ -130,7 +131,7 @@ async function getCodeCoverage(options) {
       }
     }
     if (fc.f && (0, import_objects.isObjectObject)(fc.f)) {
-      const functionCounts = Object.values(fc.f);
+      const functionCounts = (0, import_primordials.ObjectValues)(fc.f);
       for (const count of functionCounts) {
         if (typeof count === "number") {
           totals.functions.total += 1;

package/dist/cover/formatters.js

@@ -25,6 +25,7 @@ __export(formatters_exports, {
 });
 module.exports = __toCommonJS(formatters_exports);
 var import_strings = require("../strings");
+var import_primordials = require("../primordials");
 const COVERAGE_EMOJI_THRESHOLDS = [
   { emoji: " \u{1F680}", threshold: 99 },
   { emoji: " \u{1F3AF}", threshold: 95 },
@@ -38,17 +39,17 @@ const COVERAGE_EMOJI_THRESHOLDS = [
 ];
 function calculateOverall(code, type) {
   const metrics = [
-    Number.parseFloat(code.statements.percent),
-    Number.parseFloat(code.branches.percent),
-    Number.parseFloat(code.functions.percent),
-    Number.parseFloat(code.lines.percent)
-  ].map((val) => Number.isNaN(val) ? 0 : val);
+    (0, import_primordials.NumberParseFloat)(code.statements.percent),
+    (0, import_primordials.NumberParseFloat)(code.branches.percent),
+    (0, import_primordials.NumberParseFloat)(code.functions.percent),
+    (0, import_primordials.NumberParseFloat)(code.lines.percent)
+  ].map((val) => (0, import_primordials.NumberIsNaN)(val) ? 0 : val);
   if (type) {
-    const typePercent = Number.parseFloat(type.percent);
-    metrics.push(Number.isNaN(typePercent) ? 0 : typePercent);
+    const typePercent = (0, import_primordials.NumberParseFloat)(type.percent);
+    metrics.push((0, import_primordials.NumberIsNaN)(typePercent) ? 0 : typePercent);
   }
   const average = metrics.reduce((sum, val) => sum + val, 0) / metrics.length;
-  return average.toFixed(2);
+  return (0, import_primordials.NumberPrototypeToFixed)(average, 2);
 }
 function formatCoverage(options) {
   const opts = {
@@ -58,7 +59,7 @@ function formatCoverage(options) {
   };
   const { code, format, type } = opts;
   if (format === "json") {
-    return JSON.stringify({ code, type }, null, 2);
+    return (0, import_primordials.JSONStringify)({ code, type }, null, 2);
   }
   const overall = calculateOverall(code, type);
   if (format === "simple") {
@@ -86,8 +87,8 @@ function formatCoverage(options) {
       { count: 2 }
     );
   }
-  const overallValue = Number.parseFloat(overall);
-  const emoji = getCoverageEmoji(Number.isNaN(overallValue) ? 0 : overallValue);
+  const overallValue = (0, import_primordials.NumberParseFloat)(overall);
+  const emoji = getCoverageEmoji((0, import_primordials.NumberIsNaN)(overallValue) ? 0 : overallValue);
   output += `
 Overall: ${overall}%${emoji}
 `;

package/dist/cover/type.js

@@ -35,6 +35,7 @@ __export(type_exports, {
 module.exports = __toCommonJS(type_exports);
 var import_node_process = __toESM(require("node:process"));
 var import_spawn = require("../spawn");
+var import_primordials = require("../primordials");
 async function getTypeCoverage(options) {
   const opts = {
     __proto__: null,
@@ -44,7 +45,7 @@ async function getTypeCoverage(options) {
   };
   const { cwd, generateIfMissing } = opts;
   if (!cwd) {
-    throw new Error("Working directory is required.");
+    throw new import_primordials.ErrorCtor("Working directory is required.");
   }
   try {
     const result = await (0, import_spawn.spawn)("type-coverage", ["--detail"], {
@@ -57,13 +58,13 @@ async function getTypeCoverage(options) {
       return null;
     }
     return {
-      covered: Number.parseInt(match[1], 10),
+      covered: (0, import_primordials.NumberParseInt)(match[1], 10),
       percent: match[3],
-      total: Number.parseInt(match[2], 10)
+      total: (0, import_primordials.NumberParseInt)(match[2], 10)
     };
   } catch (e) {
     if (generateIfMissing) {
-      throw new Error(
+      throw new import_primordials.ErrorCtor(
         "Unable to generate type coverage. Ensure type-coverage is installed.",
         { cause: e }
       );

package/dist/crypto.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @fileoverview Crypto helpers that prefer Node builtins where available.
+ */
+/**
+ * Resolve `crypto.hash` (or `undefined` if the runtime predates it).
+ *
+ * Exported for unit tests; not part of the public API.
+ *
+ * @internal
+ */
+export declare function getNativeHash(): typeof import('node:crypto').hash | undefined;
+/**
+ * Compute a one-shot cryptographic hash.
+ *
+ * Prefers Node's `crypto.hash(algorithm, data, outputEncoding)` (added
+ * v21.7.0 / v20.12.0), which is ~30% faster than the
+ * `createHash().update().digest()` chain on small-to-medium inputs
+ * because it skips constructing the streaming `Hash` object. Falls
+ * back to that chain on older runtimes.
+ *
+ * Use this only for the one-shot case where the entire input is
+ * available as a single buffer or string; if you need to feed chunks,
+ * stay on `createHash()`.
+ *
+ * @example
+ * ```typescript
+ * import { hash } from '@socketsecurity/lib/crypto'
+ *
+ * hash('sha256', 'hello', 'hex')
+ * // '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824'
+ *
+ * hash('sha512', someBuffer, 'base64')
+ * // 'z4PhNX7vuL3xVChQ1m2AB9Yg5AULVxXcg/SpIdNs6c5H0NE8XYXysP+DGNKHfuwvY7kxvUdBeoGlODJ6+SfaPg=='
+ * ```
+ */
+export declare function hash(algorithm: string, data: string | NodeJS.ArrayBufferView, outputEncoding: 'hex' | 'base64' | 'base64url' | 'binary'): string;

package/dist/{effects/ultra.js → crypto.js}

@@ -18,47 +18,43 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var ultra_exports = {};
-__export(ultra_exports, {
-  RAINBOW_GRADIENT: () => RAINBOW_GRADIENT,
-  generateRainbowGradient: () => generateRainbowGradient
+var crypto_exports = {};
+__export(crypto_exports, {
+  getNativeHash: () => getNativeHash,
+  hash: () => hash
 });
-module.exports = __toCommonJS(ultra_exports);
-const RAINBOW_GRADIENT = [
-  // Red/pink.
-  [255, 100, 120],
-  // Orange.
-  [255, 140, 80],
-  // Yellow/gold.
-  [255, 180, 60],
-  // Yellow/green.
-  [220, 200, 80],
-  // Green.
-  [120, 200, 100],
-  // Cyan/turquoise.
-  [80, 200, 180],
-  // Blue.
-  [80, 160, 220],
-  // Purple/violet.
-  [140, 120, 220],
-  // Pink/magenta.
-  [200, 100, 200],
-  // Red/pink.
-  [255, 100, 140]
-];
-function generateRainbowGradient(textLength) {
-  const colors = [];
-  for (let i = 0; i < textLength; i += 1) {
-    const colorIndex = i % RAINBOW_GRADIENT.length;
-    const color = RAINBOW_GRADIENT[colorIndex];
-    if (color) {
-      colors.push(color);
+module.exports = __toCommonJS(crypto_exports);
+let _crypto;
+let _hash;
+let _hashProbed = false;
+// @__NO_SIDE_EFFECTS__
+function getCrypto() {
+  if (_crypto === void 0) {
+    _crypto = require("node:crypto");
+  }
+  return _crypto;
+}
+// @__NO_SIDE_EFFECTS__
+function getNativeHash() {
+  if (!_hashProbed) {
+    const fn = (/* @__PURE__ */ getCrypto()).hash;
+    if (typeof fn === "function") {
+      _hash = fn;
     }
+    _hashProbed = true;
+  }
+  return _hash;
+}
+// @__NO_SIDE_EFFECTS__
+function hash(algorithm, data, outputEncoding) {
+  const native = /* @__PURE__ */ getNativeHash();
+  if (native !== void 0) {
+    return native(algorithm, data, outputEncoding);
   }
-  return colors;
+  return (/* @__PURE__ */ getCrypto()).createHash(algorithm).update(data).digest(outputEncoding);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  RAINBOW_GRADIENT,
-  generateRainbowGradient
+  getNativeHash,
+  hash
 });

package/dist/debug.js

@@ -54,7 +54,7 @@ var import_primordials = require("./primordials");
 var import_spinner = require("./spinner");
 var import_strings = require("./strings");
 const logger = (0, import_logger.getDefaultLogger)();
-const debugByNamespace = /* @__PURE__ */ new Map();
+const debugByNamespace = new import_primordials.MapCtor();
 let _util;
 let pointingTriangle;
 // @__NO_SIDE_EFFECTS__
@@ -94,11 +94,8 @@ function getCallerInfo(stackOffset = 3) {
             const match = /(?<=^at\s+).*?(?=\s+\(|$)/.exec(line)?.[0];
             if (match) {
               name = match.replace(/^(?:async|bound|get|new|set)\s+/, "");
-              if (name.startsWith("Object.")) {
-                const afterDot = name.slice(
-                  7
-                  /*'Object.'.length*/
-                );
+              if ((0, import_primordials.StringPrototypeStartsWith)(name, "Object.")) {
+                const afterDot = (0, import_primordials.StringPrototypeSlice)(name, 7);
                 if (!(0, import_objects.hasOwn)(Object, afterDot)) {
                   name = afterDot;
                 }
@@ -145,7 +142,7 @@ function isEnabled(namespaces) {
   const names = [];
   const skips = [];
   for (const ns of split) {
-    if (ns.startsWith("-")) {
+    if ((0, import_primordials.StringPrototypeStartsWith)(ns, "-")) {
       skips.push(ns.slice(1));
     } else {
       names.push(ns);
@@ -242,13 +239,13 @@ function debugLogNs(namespacesOrOpts, ...args) {
     const supported = (0, import_is_unicode_supported.default)();
     pointingTriangle = supported ? "\u25B8" : ">";
   }
-  const text = args.at(0);
+  const text = (0, import_primordials.ArrayPrototypeAt)(args, 0);
   const logArgs = typeof text === "string" ? [
     (0, import_strings.applyLinePrefix)(
       `${callerName ? `${callerName} ${pointingTriangle} ` : ""}${text}`,
       { prefix: "[DEBUG] " }
     ),
-    ...args.slice(1)
+    ...(0, import_primordials.ArrayPrototypeSlice)(args, 1)
   ] : [`[DEBUG] ${callerName} ${pointingTriangle}`, ...args];
   const spinnerInstance = options.spinner || (0, import_spinner.getDefaultSpinner)();
   const wasSpinning = spinnerInstance?.isSpinning;
@@ -274,13 +271,13 @@ function debugNs(namespacesOrOpts, ...args) {
     const supported = (0, import_is_unicode_supported.default)();
     pointingTriangle = supported ? "\u25B8" : ">";
   }
-  const text = args.at(0);
+  const text = (0, import_primordials.ArrayPrototypeAt)(args, 0);
   const logArgs = typeof text === "string" ? [
     (0, import_strings.applyLinePrefix)(
       `${name ? `${name} ${pointingTriangle} ` : ""}${text}`,
       { prefix: "[DEBUG] " }
     ),
-    ...args.slice(1)
+    ...(0, import_primordials.ArrayPrototypeSlice)(args, 1)
   ] : args;
   const spinnerInstance = options.spinner || (0, import_spinner.getDefaultSpinner)();
   const wasSpinning = spinnerInstance?.isSpinning;
@@ -296,19 +293,19 @@ function debugtime(label) {
   let startTime;
   const impl = () => {
     if (startTime === void 0) {
-      startTime = Date.now();
+      startTime = (0, import_primordials.DateNow)();
     } else {
-      const duration = Date.now() - startTime;
+      const duration = (0, import_primordials.DateNow)() - startTime;
       util.debuglog("time")(`${label}: ${duration}ms`);
       startTime = void 0;
     }
   };
   impl.start = () => {
-    startTime = Date.now();
+    startTime = (0, import_primordials.DateNow)();
   };
   impl.end = () => {
     if (startTime !== void 0) {
-      const duration = Date.now() - startTime;
+      const duration = (0, import_primordials.DateNow)() - startTime;
       util.debuglog("time")(`${label}: ${duration}ms`);
       startTime = void 0;
     }