@socketsecurity/lib 5.25.1 → 5.26.1

package/dist/globs.js

@@ -20,8 +20,10 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var globs_exports = {};
 __export(globs_exports, {
+  canUseNodeFsGlob: () => canUseNodeFsGlob,
   defaultIgnore: () => defaultIgnore,
   getGlobMatcher: () => getGlobMatcher,
+  getMatchesGlob: () => getMatchesGlob,
   glob: () => glob,
   globStreamLicenses: () => globStreamLicenses,
   globSync: () => globSync
@@ -29,10 +31,42 @@ __export(globs_exports, {
 module.exports = __toCommonJS(globs_exports);
 var import_objects = require("./objects");
 var import_globs = require("./paths/globs");
+var import_normalize = require("./paths/normalize");
+var import_promises = require("./promises");
+var import_primordials = require("./primordials");
 let _fastGlob;
+let _fs;
+let _fsPromises;
 let _picomatch;
+let _matchesGlob;
+let _matchesGlobProbed = false;
+// @__NO_SIDE_EFFECTS__
+function getFs() {
+  if (_fs === void 0) {
+    _fs = require("node:fs");
+  }
+  return _fs;
+}
+// @__NO_SIDE_EFFECTS__
+function getFsPromises() {
+  if (_fsPromises === void 0) {
+    _fsPromises = require("node:fs/promises");
+  }
+  return _fsPromises;
+}
+// @__NO_SIDE_EFFECTS__
+function getMatchesGlob() {
+  if (!_matchesGlobProbed) {
+    const fn = require("node:path").matchesGlob;
+    if (typeof fn === "function") {
+      _matchesGlob = fn;
+    }
+    _matchesGlobProbed = true;
+  }
+  return _matchesGlob;
+}
 const MATCHER_CACHE_MAX_SIZE = 100;
-const matcherCache = /* @__PURE__ */ new Map();
+const matcherCache = new import_primordials.MapCtor();
 const defaultIgnore = (0, import_objects.objectFreeze)([
   // Most of these ignored files can be included specifically if included in the
   // files globs. Exceptions to this are:
@@ -80,6 +114,30 @@ function getFastGlob() {
   }
   return _fastGlob;
 }
+function stripTrailingSlash(pattern) {
+  if (pattern.length > 1 && (0, import_primordials.StringPrototypeCharCodeAt)(pattern, pattern.length - 1) === 47) {
+    return pattern.slice(0, -1);
+  }
+  return pattern;
+}
+function normalizeGlobResults(out) {
+  for (let i = 0; i < out.length; i += 1) {
+    out[i] = (0, import_normalize.normalizePath)(out[i]);
+  }
+  return out;
+}
+function normalizeIgnorePatterns(ignore) {
+  if (!(0, import_primordials.ArrayIsArray)(ignore)) {
+    return void 0;
+  }
+  const source = ignore;
+  const { length } = source;
+  const normalized = new import_primordials.ArrayCtor(length);
+  for (let i = 0; i < length; i++) {
+    normalized[i] = stripTrailingSlash(source[i]);
+  }
+  return normalized;
+}
 // @__NO_SIDE_EFFECTS__
 function getPicomatch() {
   if (_picomatch === void 0) {
@@ -89,12 +147,12 @@ function getPicomatch() {
 }
 // @__NO_SIDE_EFFECTS__
 function getGlobMatcher(glob2, options) {
-  const patterns = Array.isArray(glob2) ? glob2 : [glob2];
+  const patterns = (0, import_primordials.ArrayIsArray)(glob2) ? glob2 : [glob2];
   const sortedPatterns = [...patterns].sort();
-  const sortedOptions = options ? Object.keys(options).sort().map((k) => {
+  const sortedOptions = options ? (0, import_primordials.ObjectKeys)(options).sort().map((k) => {
     const value = options[k];
-    const normalized = Array.isArray(value) ? [...value].sort() : value;
-    return `${k}:${JSON.stringify(normalized)}`;
+    const normalized = (0, import_primordials.ArrayIsArray)(value) ? [...value].sort() : value;
+    return `${k}:${(0, import_primordials.JSONStringify)(normalized)}`;
   }).join(",") : "";
   const key = `${sortedPatterns.join("|")}:${sortedOptions}`;
   const existing = matcherCache.get(key);
@@ -109,26 +167,63 @@ function getGlobMatcher(glob2, options) {
       matcherCache.delete(oldest);
     }
   }
-  const positivePatterns = patterns.filter((p) => !p.startsWith("!"));
-  const negativePatterns = patterns.filter((p) => p.startsWith("!")).map((p) => p.slice(1));
-  const matchOptions = {
-    dot: true,
-    nocase: true,
-    ...options,
-    ...negativePatterns.length > 0 ? { ignore: negativePatterns } : {}
-  };
-  const picomatch = /* @__PURE__ */ getPicomatch();
-  const matcher = picomatch(
-    positivePatterns.length > 0 ? positivePatterns : patterns,
-    matchOptions
-  );
+  let matcher;
+  if (patterns.length === 1 && !(0, import_primordials.StringPrototypeStartsWith)(patterns[0], "!") && options !== void 0 && options.nocase === false && options.dot === false && (options.ignore === void 0 || options.ignore.length === 0)) {
+    const matchesGlob = /* @__PURE__ */ getMatchesGlob();
+    if (matchesGlob !== void 0) {
+      const pattern = patterns[0];
+      matcher = (p) => matchesGlob(p, pattern);
+    }
+  }
+  if (matcher === void 0) {
+    const positivePatterns = patterns.filter(
+      (p) => !(0, import_primordials.StringPrototypeStartsWith)(p, "!")
+    );
+    const negativePatterns = patterns.filter((p) => (0, import_primordials.StringPrototypeStartsWith)(p, "!")).map((p) => p.slice(1));
+    const matchOptions = {
+      dot: true,
+      nocase: true,
+      ...options,
+      ...negativePatterns.length > 0 ? { ignore: negativePatterns } : {}
+    };
+    const picomatch = /* @__PURE__ */ getPicomatch();
+    matcher = picomatch(
+      positivePatterns.length > 0 ? positivePatterns : patterns,
+      matchOptions
+    );
+  }
   matcherCache.set(key, matcher);
   return matcher;
 }
+function canUseNodeFsGlob(options) {
+  if (!options) {
+    return true;
+  }
+  for (const key of (0, import_primordials.ObjectKeys)(options)) {
+    if (key !== "cwd" && key !== "ignore") {
+      return false;
+    }
+  }
+  return true;
+}
 // @__NO_SIDE_EFFECTS__
-function glob(patterns, options) {
+async function glob(patterns, options) {
+  const normalizedIgnore = normalizeIgnorePatterns(options?.ignore);
+  if (canUseNodeFsGlob(options)) {
+    const out2 = await (0, import_promises.fromAsync)(
+      (/* @__PURE__ */ getFsPromises()).glob(patterns, {
+        ...options?.cwd ? { cwd: options.cwd } : {},
+        ...normalizedIgnore ? { exclude: normalizedIgnore } : {}
+      })
+    );
+    return normalizeGlobResults(out2);
+  }
   const fastGlob = /* @__PURE__ */ getFastGlob();
-  return fastGlob.glob(patterns, options);
+  const out = await fastGlob.glob(patterns, {
+    ...options,
+    ...normalizedIgnore ? { ignore: normalizedIgnore } : {}
+  });
+  return normalizeGlobResults(out);
 }
 // @__NO_SIDE_EFFECTS__
 function globStreamLicenses(dirname, options) {
@@ -138,10 +233,8 @@ function globStreamLicenses(dirname, options) {
     recursive,
     ...globOptions
   } = { __proto__: null, ...options };
-  const ignore = [
-    ...Array.isArray(ignoreOpt) ? ignoreOpt : defaultIgnore,
-    "**/*.{cjs,cts,js,json,mjs,mts,ts}"
-  ];
+  const baseIgnore = (0, import_primordials.ArrayIsArray)(ignoreOpt) ? normalizeIgnorePatterns(ignoreOpt) : defaultIgnore;
+  const ignore = [...baseIgnore, "**/*.{cjs,cts,js,json,mjs,mts,ts}"];
   if (ignoreOriginals) {
     ignore.push(import_globs.LICENSE_ORIGINAL_GLOB_RECURSIVE);
   }
@@ -160,13 +253,29 @@ function globStreamLicenses(dirname, options) {
 }
 // @__NO_SIDE_EFFECTS__
 function globSync(patterns, options) {
+  const normalizedIgnore = normalizeIgnorePatterns(options?.ignore);
+  if (canUseNodeFsGlob(options)) {
+    return normalizeGlobResults([
+      ...(/* @__PURE__ */ getFs()).globSync(patterns, {
+        ...options?.cwd ? { cwd: options.cwd } : {},
+        ...normalizedIgnore ? { exclude: normalizedIgnore } : {}
+      })
+    ]);
+  }
   const fastGlob = /* @__PURE__ */ getFastGlob();
-  return fastGlob.globSync(patterns, options);
+  return normalizeGlobResults(
+    fastGlob.globSync(patterns, {
+      ...options,
+      ...normalizedIgnore ? { ignore: normalizedIgnore } : {}
+    })
+  );
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  canUseNodeFsGlob,
   defaultIgnore,
   getGlobMatcher,
+  getMatchesGlob,
   glob,
   globStreamLicenses,
   globSync

package/dist/http-request.d.ts

@@ -905,9 +905,10 @@ export declare function parseChecksums(text: string): Checksums;
  *
  * @example
  * ```ts
- * const delay = parseRetryAfterHeader(response.headers['retry-after'])
- * if (delay !== undefined) {
- *   await new Promise(resolve => setTimeout(resolve, delay))
+ * import { setTimeout as delay } from 'node:timers/promises'
+ * const ms = parseRetryAfterHeader(response.headers['retry-after'])
+ * if (ms !== undefined) {
+ *   await delay(ms)
  * }
  * ```
  */

package/dist/http-request.js

@@ -33,8 +33,10 @@ __export(http_request_exports, {
   sanitizeHeaders: () => sanitizeHeaders
 });
 module.exports = __toCommonJS(http_request_exports);
+var import_promises = require("node:timers/promises");
 var import_socket = require("./constants/socket");
 var import_fs = require("./fs");
+var import_primordials = require("./primordials");
 class HttpResponseError extends Error {
   response;
   constructor(response, message) {
@@ -104,19 +106,24 @@ async function httpDownloadAttempt(url, destPath, options) {
   }
   const res = response.rawResponse;
   if (!res) {
-    throw new Error("Stream response missing rawResponse");
+    throw new import_primordials.ErrorCtor("Stream response missing rawResponse");
   }
   const { createWriteStream } = /* @__PURE__ */ getFs();
-  const totalSize = Number.parseInt(
+  const totalSize = (0, import_primordials.NumberParseInt)(
     response.headers["content-length"] || "0",
     10
   );
-  return await new Promise((resolve, reject) => {
+  return await new import_primordials.PromiseCtor((resolve, reject) => {
     let downloadedSize = 0;
     const fileStream = createWriteStream(destPath);
     const cleanupPartial = () => {
-      (/* @__PURE__ */ getFs()).promises.unlink(destPath).catch(() => {
-      });
+      ;
+      (async () => {
+        try {
+          await (/* @__PURE__ */ getFs()).promises.unlink(destPath);
+        } catch {
+        }
+      })();
     };
     fileStream.on("error", (error) => {
       fileStream.destroy();
@@ -164,7 +171,7 @@ async function httpRequestAttempt(url, options) {
     stream = false,
     timeout = 3e4
   } = { __proto__: null, ...options };
-  const startTime = Date.now();
+  const startTime = (0, import_primordials.DateNow)();
   const streamHeaders = body && typeof body === "object" && "getHeaders" in body && typeof body.getHeaders === "function" ? body.getHeaders() : void 0;
   const mergedHeaders = {
     "User-Agent": import_socket.SOCKET_LIB_USER_AGENT,
@@ -172,7 +179,7 @@ async function httpRequestAttempt(url, options) {
     ...headers
   };
   hooks?.onRequest?.({ method, url, headers: mergedHeaders, timeout });
-  return await new Promise((resolve, reject) => {
+  return await new import_primordials.PromiseCtor((resolve, reject) => {
     let settled = false;
     const resolveOnce = (response) => {
       if (settled) {
@@ -193,7 +200,7 @@ async function httpRequestAttempt(url, options) {
       emitResponse({ error: err });
       reject(err);
     };
-    const parsedUrl = new URL(url);
+    const parsedUrl = new import_primordials.URLCtor(url);
     const isHttps = parsedUrl.protocol === "https:";
     const httpModule = isHttps ? /* @__PURE__ */ getHttps() : /* @__PURE__ */ getHttp();
     const requestOptions = {
@@ -210,7 +217,7 @@ async function httpRequestAttempt(url, options) {
     const emitResponse = (info) => {
       try {
         hooks?.onResponse?.({
-          duration: Date.now() - startTime,
+          duration: (0, import_primordials.DateNow)() - startTime,
           method,
           url,
           ...info
@@ -429,7 +436,7 @@ async function fetchChecksums(url, options) {
   };
   const response = await httpRequest(url, { ca, headers, timeout });
   if (!response.ok) {
-    throw new Error(
+    throw new import_primordials.ErrorCtor(
       `Failed to fetch checksums from ${url}: ${response.status} ${response.statusText}`
     );
   }
@@ -455,7 +462,7 @@ async function httpDownload(url, destPath, options) {
   } else if (logger) {
     let lastPercent = 0;
     progressCallback = (downloaded, total) => {
-      const percent = total === 0 ? 0 : Math.floor(downloaded / total * 100);
+      const percent = total === 0 ? 0 : (0, import_primordials.MathFloor)(downloaded / total * 100);
       if (percent >= lastPercent + progressInterval) {
         logger.log(
           `  Progress: ${percent}% (${(downloaded / 1024 / 1024).toFixed(1)} MB / ${(total / 1024 / 1024).toFixed(1)} MB)`
@@ -487,11 +494,11 @@ async function httpDownload(url, destPath, options) {
         const computedHash = crypto.createHash("sha256").update(fileContent).digest("hex");
         const expectedHash = sha256.toLowerCase();
         if (computedHash.length !== expectedHash.length || !crypto.timingSafeEqual(
-          Buffer.from(computedHash),
+          (0, import_primordials.BufferFrom)(computedHash),
           Buffer.from(expectedHash)
         )) {
           await (0, import_fs.safeDelete)(tempPath);
-          throw new Error(
+          throw new import_primordials.ErrorCtor(
             `Checksum verification failed for ${url}
 Expected: ${expectedHash}
 Computed: ${computedHash}`
@@ -512,10 +519,10 @@ Computed: ${computedHash}`
         break;
       }
       const delayMs = retryDelay * 2 ** attempt;
-      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      await (0, import_promises.setTimeout)(delayMs);
     }
   }
-  throw lastError || new Error("Download failed after retries");
+  throw lastError || new import_primordials.ErrorCtor("Download failed after retries");
 }
 async function httpJson(url, options) {
   const {
@@ -547,7 +554,7 @@ async function httpJson(url, options) {
   try {
     return response.json();
   } catch (e) {
-    throw new Error("Failed to parse JSON response", { cause: e });
+    throw new import_primordials.ErrorCtor("Failed to parse JSON response", { cause: e });
   }
 }
 async function httpRequest(url, options) {
@@ -569,7 +576,7 @@ async function httpRequest(url, options) {
   } = { __proto__: null, ...options };
   const isStreamBody = body !== void 0 && typeof body === "object" && typeof body.pipe === "function";
   if (isStreamBody && retries > 0) {
-    throw new Error(
+    throw new import_primordials.ErrorCtor(
       "Streaming body (Readable/FormData) cannot be used with retries. Streams are consumed on first attempt and cannot be replayed. Set retries: 0 or buffer the body as a string/Buffer."
     );
   }
@@ -606,14 +613,14 @@ async function httpRequest(url, options) {
         if (retryResult === false) {
           break;
         }
-        const actualDelay = typeof retryResult === "number" && !Number.isNaN(retryResult) ? Math.max(0, retryResult) : delayMs;
-        await new Promise((resolve) => setTimeout(resolve, actualDelay));
+        const actualDelay = typeof retryResult === "number" && !(0, import_primordials.NumberIsNaN)(retryResult) ? (0, import_primordials.MathMax)(0, retryResult) : delayMs;
+        await (0, import_promises.setTimeout)(actualDelay);
       } else {
-        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        await (0, import_promises.setTimeout)(delayMs);
       }
     }
   }
-  throw lastError || new Error("Request failed after retries");
+  throw lastError || new import_primordials.ErrorCtor("Request failed after retries");
 }
 async function httpText(url, options) {
   const {
@@ -649,9 +656,9 @@ const CHECKSUM_GNU_RE = /^([a-fA-F0-9]{64})\s+(.+)$/;
 const RETRY_AFTER_INT_RE = /^\d+$/;
 function parseChecksums(text) {
   const checksums = { __proto__: null };
-  for (const line of text.split("\n")) {
+  for (const line of (0, import_primordials.StringPrototypeSplit)(text, "\n")) {
     const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) {
+    if (!trimmed || (0, import_primordials.StringPrototypeStartsWith)(trimmed, "#")) {
       continue;
     }
     const bsdMatch = CHECKSUM_BSD_RE.exec(trimmed);
@@ -670,7 +677,7 @@ function parseRetryAfterHeader(value) {
   if (!value) {
     return void 0;
   }
-  const raw = Array.isArray(value) ? value[0] : value;
+  const raw = (0, import_primordials.ArrayIsArray)(value) ? value[0] : value;
   if (!raw) {
     return void 0;
   }
@@ -679,9 +686,9 @@ function parseRetryAfterHeader(value) {
     const seconds = Number(trimmed);
     return seconds * 1e3;
   }
-  const date = new Date(raw);
-  if (!Number.isNaN(date.getTime())) {
-    const delayMs = date.getTime() - Date.now();
+  const date = new import_primordials.DateCtor(raw);
+  if (!(0, import_primordials.NumberIsNaN)(date.getTime())) {
+    const delayMs = date.getTime() - (0, import_primordials.DateNow)();
     if (delayMs > 0) {
       return delayMs;
     }
@@ -693,7 +700,7 @@ async function readIncomingResponse(msg) {
   for await (const chunk of msg) {
     chunks.push(chunk);
   }
-  const body = Buffer.concat(chunks);
+  const body = (0, import_primordials.BufferConcat)(chunks);
   const status = msg.statusCode ?? 0;
   const statusText = msg.statusMessage ?? "";
   return {
@@ -703,7 +710,7 @@ async function readIncomingResponse(msg) {
     ),
     body,
     headers: msg.headers,
-    json: () => JSON.parse(body.toString("utf8")),
+    json: () => (0, import_primordials.JSONParse)(body.toString("utf8")),
     ok: status >= 200 && status < 300,
     rawResponse: msg,
     status,
@@ -715,7 +722,7 @@ function sanitizeHeaders(headers) {
   if (!headers) {
     return {};
   }
-  const sensitiveHeaders = /* @__PURE__ */ new Set([
+  const sensitiveHeaders = new import_primordials.SetCtor([
     "authorization",
     "cookie",
     "proxy-authorization",
@@ -726,11 +733,11 @@ function sanitizeHeaders(headers) {
   const result = {
     __proto__: null
   };
-  for (const key of Object.keys(headers)) {
+  for (const key of (0, import_primordials.ObjectKeys)(headers)) {
     const value = headers[key];
     if (sensitiveHeaders.has(key.toLowerCase())) {
       result[key] = "[REDACTED]";
-    } else if (Array.isArray(value)) {
+    } else if ((0, import_primordials.ArrayIsArray)(value)) {
       result[key] = value.join(", ");
     } else if (value !== void 0 && value !== null) {
       result[key] = String(value);

package/dist/ipc-cli.js

@@ -23,6 +23,7 @@ __export(ipc_cli_exports, {
   getIpc: () => getIpc
 });
 module.exports = __toCommonJS(ipc_cli_exports);
+var import_primordials = require("./primordials");
 let _ipcObject;
 async function getIpc(key) {
   if (_ipcObject === void 0) {
@@ -49,7 +50,7 @@ async function getIpc(key) {
     if (env["SOCKET_CLI_SHADOW_SILENT"]) {
       _ipcObject.SOCKET_CLI_SHADOW_SILENT = env["SOCKET_CLI_SHADOW_SILENT"] === "true" || env["SOCKET_CLI_SHADOW_SILENT"] === "1";
     }
-    Object.freeze(_ipcObject);
+    (0, import_primordials.ObjectFreeze)(_ipcObject);
   }
   return key ? _ipcObject[key] : _ipcObject;
 }

package/dist/ipc.js

@@ -38,6 +38,7 @@ var import_node_process = __toESM(require("node:process"));
 var import_typebox = require("./external/@sinclair/typebox");
 var import_socket = require("./paths/socket");
 var import_parse = require("./schema/parse");
+var import_primordials = require("./primordials");
 const IpcStubSchema = import_typebox.Type.Object({
   /** Process ID that created the stub. */
   pid: import_typebox.Type.Integer({ minimum: 1 }),
@@ -58,12 +59,12 @@ async function ensureIpcDirectory(filePath) {
   }
   const stats = await fs.promises.lstat(dir);
   if (!stats.isDirectory()) {
-    throw new Error(`IPC path is not a directory: ${dir}`);
+    throw new import_primordials.ErrorCtor(`IPC path is not a directory: ${dir}`);
   }
   const getuid = import_node_process.default.getuid;
   const ownUid = typeof getuid === "function" ? getuid.call(import_node_process.default) : -1;
   if (ownUid !== -1 && stats.uid !== ownUid) {
-    throw new Error(
+    throw new import_primordials.ErrorCtor(
       `IPC directory ${dir} is owned by another user (uid ${stats.uid}); refusing to use it.`
     );
   }
@@ -98,7 +99,7 @@ async function writeIpcStub(appName, data) {
   const ipcData = {
     data,
     pid: import_node_process.default.pid,
-    timestamp: Date.now()
+    timestamp: (0, import_primordials.DateNow)()
   };
   const validated = (0, import_parse.parseSchema)(IpcStubSchema, ipcData);
   const fs = /* @__PURE__ */ getFs();
@@ -116,7 +117,7 @@ async function writeIpcStub(appName, data) {
     }
   }
   try {
-    await handle.writeFile(JSON.stringify(validated, null, 2), "utf8");
+    await handle.writeFile((0, import_primordials.JSONStringify)(validated, null, 2), "utf8");
   } finally {
     await handle.close();
   }

package/dist/json/edit.js

@@ -36,6 +36,7 @@ module.exports = __toCommonJS(edit_exports);
 var import_node_process = __toESM(require("node:process"));
 var import_promises = require("node:timers/promises");
 var import_errors = require("../errors");
+var import_primordials = require("../primordials");
 var import_format = require("./format");
 const identSymbol = import_format.INDENT_SYMBOL;
 const newlineSymbol = import_format.NEWLINE_SYMBOL;
@@ -68,7 +69,7 @@ async function readFile(filepath) {
       await (0, import_promises.setTimeout)(delay);
     }
   }
-  throw new Error("Unreachable code");
+  throw new import_primordials.ErrorCtor("Unreachable code");
 }
 async function retryWrite(filepath, content, retries = 3, baseDelay = 10) {
   const fs = /* @__PURE__ */ getFs();
@@ -190,7 +191,7 @@ function getEditableJsonClass() {
       }
       async save(options) {
         if (!this._canSave || this.content === void 0) {
-          throw new Error("No file path to save to");
+          throw new import_primordials.ErrorCtor("No file path to save to");
         }
         if (!(0, import_format.shouldSave)(
           this.content,
@@ -215,7 +216,7 @@ function getEditableJsonClass() {
       }
       saveSync(options) {
         if (!this._canSave || this.content === void 0) {
-          throw new Error("No file path to save to");
+          throw new import_primordials.ErrorCtor("No file path to save to");
         }
         if (!(0, import_format.shouldSave)(
           this.content,

package/dist/json/format.js

@@ -33,6 +33,7 @@ __export(format_exports, {
   stripFormattingSymbols: () => stripFormattingSymbols
 });
 module.exports = __toCommonJS(format_exports);
+var import_primordials = require("../primordials");
 const INDENT_SYMBOL = Symbol.for("indent");
 const NEWLINE_SYMBOL = Symbol.for("newline");
 function detectIndent(json) {
@@ -85,7 +86,7 @@ function shouldSave(currentContent, originalContent, originalFileContent, option
 }
 function sortKeys(obj) {
   const sorted = { __proto__: null };
-  const keys = Object.keys(obj).sort();
+  const keys = (0, import_primordials.ObjectKeys)(obj).sort();
   for (const key of keys) {
     sorted[key] = obj[key];
   }
@@ -95,7 +96,7 @@ function stringifyWithFormatting(content, formatting) {
   const { indent, newline } = formatting;
   const format = indent === void 0 || indent === null ? "  " : indent;
   const eol = newline === void 0 || newline === null ? "\n" : newline;
-  return `${JSON.stringify(content, void 0, format)}
+  return `${(0, import_primordials.JSONStringify)(content, void 0, format)}
 `.replace(/\n/g, eol);
 }
 function stripFormattingSymbols(content) {

package/dist/json/parse.js

@@ -27,6 +27,7 @@ __export(parse_exports, {
 module.exports = __toCommonJS(parse_exports);
 var import_validate = require("../schema/validate");
 var import_strings = require("../strings");
+var import_primordials = require("../primordials");
 const JSONParse = JSON.parse;
 // @__NO_SIDE_EFFECTS__
 function isBuffer(x) {
@@ -71,10 +72,10 @@ function jsonParse(content, options) {
   }
   return void 0;
 }
-const DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+const DANGEROUS_KEYS = new import_primordials.SetCtor(["__proto__", "constructor", "prototype"]);
 function prototypePollutionReviver(key, value) {
   if (DANGEROUS_KEYS.has(key)) {
-    throw new Error(
+    throw new import_primordials.ErrorCtor(
       "JSON contains potentially malicious prototype pollution keys"
     );
   }
@@ -84,9 +85,9 @@ const DEFAULT_MAX_SIZE = 10 * 1024 * 1024;
 // @__NO_SIDE_EFFECTS__
 function safeJsonParse(jsonString, schema, options = {}) {
   const { allowPrototype = false, maxSize = DEFAULT_MAX_SIZE } = options;
-  const byteLength = Buffer.byteLength(jsonString, "utf8");
+  const byteLength = (0, import_primordials.BufferByteLength)(jsonString, "utf8");
   if (byteLength > maxSize) {
-    throw new Error(
+    throw new import_primordials.ErrorCtor(
       `JSON string exceeds maximum size limit${maxSize !== DEFAULT_MAX_SIZE ? ` of ${maxSize} bytes` : ""}`
     );
   }
@@ -94,13 +95,13 @@ function safeJsonParse(jsonString, schema, options = {}) {
   try {
     parsed = allowPrototype ? JSONParse(jsonString) : JSONParse(jsonString, prototypePollutionReviver);
   } catch (e) {
-    throw new Error(`Failed to parse JSON: ${e}`);
+    throw new import_primordials.ErrorCtor(`Failed to parse JSON: ${e}`);
   }
   if (schema) {
     const result = (0, import_validate.validateSchema)(schema, parsed);
     if (!result.ok) {
       const summary = result.errors.map((e) => `${e.path.join(".") || "(root)"}: ${e.message}`).join(", ");
-      throw new Error(`Validation failed: ${summary}`);
+      throw new import_primordials.ErrorCtor(`Validation failed: ${summary}`);
     }
     return result.value;
   }

package/dist/links.js

@@ -38,6 +38,7 @@ var import_yoctocolors_cjs = __toESM(require("./external/yoctocolors-cjs"));
 var import_context = require("./themes/context");
 var import_themes = require("./themes/themes");
 var import_utils = require("./themes/utils");
+var import_primordials = require("./primordials");
 function link(text, url, options) {
   const opts = { __proto__: null, fallback: false, ...options };
   const theme = typeof opts.theme === "string" ? import_themes.THEMES[opts.theme] : opts.theme ?? (0, import_context.getTheme)();
@@ -47,7 +48,7 @@ function link(text, url, options) {
   if (typeof linkColor === "string" && linkColor !== "inherit") {
     const colorMethod = colors[linkColor];
     colored = colorMethod ? colorMethod(text) : colors.cyan(text);
-  } else if (Array.isArray(linkColor)) {
+  } else if ((0, import_primordials.ArrayIsArray)(linkColor)) {
     colored = colors.cyan(text);
   } else {
     colored = colors.cyan(text);