@socketsecurity/lib 5.26.0 → 5.27.0

package/dist/releases/github-downloads.js

@@ -0,0 +1,155 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var github_downloads_exports = {};
+__export(github_downloads_exports, {
+  downloadGitHubRelease: () => downloadGitHubRelease,
+  downloadReleaseAsset: () => downloadReleaseAsset
+});
+module.exports = __toCommonJS(github_downloads_exports);
+var import_node_process = __toESM(require("node:process"));
+var import_fs = require("../fs");
+var import_http_request = require("../http-request");
+var import_logger = require("../logger");
+var import_primordials = require("../primordials");
+var import_spawn = require("../spawn");
+var import_github_api = require("./github-api");
+const logger = (0, import_logger.getDefaultLogger)();
+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 downloadGitHubRelease(config) {
+  const {
+    assetName,
+    binaryName,
+    cwd = import_node_process.default.cwd(),
+    downloadDir = "build/downloaded",
+    owner,
+    platformArch,
+    quiet = false,
+    removeMacOSQuarantine = true,
+    repo,
+    tag: explicitTag,
+    toolName,
+    toolPrefix
+  } = config;
+  let tag;
+  if (explicitTag) {
+    tag = explicitTag;
+  } else if (toolPrefix) {
+    const latestTag = await (0, import_github_api.getLatestRelease)(toolPrefix, { owner, repo });
+    if (!latestTag) {
+      throw new import_primordials.ErrorCtor(`No ${toolPrefix} release found in ${owner}/${repo}`);
+    }
+    tag = latestTag;
+  } else {
+    throw new import_primordials.ErrorCtor("Either toolPrefix or tag must be provided");
+  }
+  const path = /* @__PURE__ */ getPath();
+  const resolvedDownloadDir = path.isAbsolute(downloadDir) ? downloadDir : path.join(cwd, downloadDir);
+  const binaryDir = resolvedDownloadDir;
+  const binaryPath = path.join(binaryDir, binaryName);
+  const versionPath = path.join(binaryDir, ".version");
+  const fs = /* @__PURE__ */ getFs();
+  if (fs.existsSync(versionPath) && fs.existsSync(binaryPath)) {
+    const cachedVersion = (await fs.promises.readFile(versionPath, "utf8")).trim();
+    if (cachedVersion === tag && fs.existsSync(binaryPath)) {
+      if (!quiet) {
+        logger.info(`Using cached ${toolName} (${platformArch}): ${binaryPath}`);
+      }
+      return binaryPath;
+    }
+  }
+  if (!quiet) {
+    logger.info(`Downloading ${toolName} for ${platformArch}...`);
+  }
+  await downloadReleaseAsset(
+    tag,
+    assetName,
+    binaryPath,
+    { owner, repo },
+    { quiet }
+  );
+  const isWindows = (0, import_primordials.StringPrototypeEndsWith)(binaryName, ".exe");
+  if (!isWindows) {
+    fs.chmodSync(binaryPath, 493);
+    if (removeMacOSQuarantine && import_node_process.default.platform === "darwin" && (0, import_primordials.StringPrototypeStartsWith)(platformArch, "darwin")) {
+      try {
+        await (0, import_spawn.spawn)("xattr", ["-d", "com.apple.quarantine", binaryPath], {
+          stdio: "ignore"
+        });
+      } catch {
+      }
+    }
+  }
+  await fs.promises.writeFile(versionPath, tag, "utf8");
+  if (!quiet) {
+    logger.info(`Downloaded ${toolName} to ${binaryPath}`);
+  }
+  return binaryPath;
+}
+async function downloadReleaseAsset(tag, assetPattern, outputPath, repoConfig, options = {}) {
+  const { owner, repo } = repoConfig;
+  const { quiet = false } = options;
+  const downloadUrl = await (0, import_github_api.getReleaseAssetUrl)(tag, assetPattern, {
+    owner,
+    repo
+  });
+  if (!downloadUrl) {
+    const patternDesc = typeof assetPattern === "string" ? assetPattern : "matching pattern";
+    throw new import_primordials.ErrorCtor(`Asset ${patternDesc} not found in release ${tag}`);
+  }
+  const path = /* @__PURE__ */ getPath();
+  await (0, import_fs.safeMkdir)(path.dirname(outputPath));
+  await (0, import_http_request.httpDownload)(downloadUrl, outputPath, {
+    logger: quiet ? void 0 : logger,
+    progressInterval: 10,
+    retries: 2,
+    retryDelay: 5e3
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  downloadGitHubRelease,
+  downloadReleaseAsset
+});

package/dist/releases/github-types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @fileoverview Public types for GitHub release download utilities.
+ */
+/**
+ * Pattern for matching release assets.
+ * Can be either:
+ * - A string with glob pattern syntax
+ * - A prefix/suffix pair for explicit matching (backward compatible)
+ * - A RegExp for complex patterns
+ *
+ * String patterns support full glob syntax via picomatch.
+ * Examples:
+ * - Simple wildcard: yoga-sync-*.mjs matches yoga-sync-abc123.mjs
+ * - Complex: models-*.tar.gz matches models-2024-01-15.tar.gz
+ * - Prefix wildcard: *-models.tar.gz matches foo-models.tar.gz
+ * - Suffix wildcard: yoga-* matches yoga-layout
+ * - Brace expansion: {yoga,models}-*.{mjs,js} matches yoga-abc.mjs or models-xyz.js
+ *
+ * For backward compatibility, prefix/suffix objects are still supported but glob patterns are recommended.
+ */
+export type AssetPattern = string | {
+    prefix: string;
+    suffix: string;
+} | RegExp;
+/**
+ * Configuration for downloading a GitHub release.
+ */
+export interface DownloadGitHubReleaseConfig {
+    /** Asset name on GitHub. */
+    assetName: string;
+    /** Binary filename (e.g., 'node', 'binject'). */
+    binaryName: string;
+    /** Working directory (defaults to process.cwd()). */
+    cwd?: string;
+    /** Download destination directory. @default 'build/downloaded' */
+    downloadDir?: string;
+    /** GitHub repository owner/organization. */
+    owner: string;
+    /** Platform-arch identifier (e.g., 'linux-x64-musl'). */
+    platformArch: string;
+    /** Suppress log messages. @default false */
+    quiet?: boolean;
+    /** Remove macOS quarantine attribute after download. @default true */
+    removeMacOSQuarantine?: boolean;
+    /** GitHub repository name. */
+    repo: string;
+    /** Specific release tag to download. */
+    tag?: string;
+    /** Tool name for directory structure. */
+    toolName: string;
+    /** Tool prefix for finding latest release. */
+    toolPrefix?: string;
+}
+/**
+ * Configuration for repository access.
+ */
+export interface RepoConfig {
+    /**
+     * GitHub repository owner/organization.
+     */
+    owner: string;
+    /**
+     * GitHub repository name.
+     */
+    repo: string;
+}

package/dist/{effects/types.js → releases/github-types.js}

@@ -14,5 +14,5 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-module.exports = __toCommonJS(types_exports);
+var github_types_exports = {};
+module.exports = __toCommonJS(github_types_exports);

package/dist/releases/socket-btm.d.ts

@@ -2,7 +2,7 @@
  * @fileoverview Socket-btm release download utilities.
  */
 import { type Arch, type Libc, type Platform } from '../constants/platform';
-import { type AssetPattern } from './github';
+import type { AssetPattern } from './github-types';
 export type { Arch, Libc, Platform };
 /**
  * Socket-btm GitHub repository configuration.

package/dist/releases/socket-btm.js

@@ -29,7 +29,9 @@ __export(socket_btm_exports, {
 });
 module.exports = __toCommonJS(socket_btm_exports);
 var import_platform = require("../constants/platform");
-var import_github = require("./github");
+var import_github_api = require("./github-api");
+var import_github_downloads = require("./github-downloads");
+var import_primordials = require("../primordials");
 const SOCKET_BTM_REPO = {
   owner: "SocketDev",
   repo: "socket-btm"
@@ -93,27 +95,25 @@ async function downloadSocketBtmRelease(tool, options) {
       resolvedAsset = asset;
     } else {
       if (tag) {
-        throw new Error(
+        throw new import_primordials.ErrorCtor(
           "Cannot use asset pattern with explicit tag. Either provide exact asset name or omit tag."
         );
       }
-      resolvedTag = await (0, import_github.getLatestRelease)(toolPrefix, SOCKET_BTM_REPO, {
-        assetPattern: asset,
-        quiet
+      resolvedTag = await (0, import_github_api.getLatestRelease)(toolPrefix, SOCKET_BTM_REPO, {
+        assetPattern: asset
       }) ?? void 0;
       if (!resolvedTag) {
-        throw new Error(`No ${tool} release with matching asset pattern found`);
+        throw new import_primordials.ErrorCtor(
+          `No ${tool} release with matching asset pattern found`
+        );
       }
-      const assetUrl = await (0, import_github.getReleaseAssetUrl)(
+      const assetUrl = await (0, import_github_api.getReleaseAssetUrl)(
         resolvedTag,
         asset,
-        SOCKET_BTM_REPO,
-        {
-          quiet
-        }
+        SOCKET_BTM_REPO
       );
       if (!assetUrl) {
-        throw new Error(`No matching asset found in release ${resolvedTag}`);
+        throw new import_primordials.ErrorCtor(`No matching asset found in release ${resolvedTag}`);
       }
       resolvedAsset = assetUrl.split("/").pop() || asset.toString();
     }
@@ -169,12 +169,12 @@ async function downloadSocketBtmRelease(tool, options) {
       removeMacOSQuarantine
     };
   }
-  return await (0, import_github.downloadGitHubRelease)(downloadConfig);
+  return await (0, import_github_downloads.downloadGitHubRelease)(downloadConfig);
 }
 function getBinaryAssetName(binaryBaseName, platform, arch, libc) {
   const mappedArch = ARCH_MAP[arch];
   if (!mappedArch) {
-    throw new Error(`Unsupported architecture: ${arch}`);
+    throw new import_primordials.ErrorCtor(`Unsupported architecture: ${arch}`);
   }
   const muslSuffix = platform === "linux" && libc === "musl" ? "-musl" : "";
   const ext = platform === "win32" ? ".exe" : "";
@@ -187,7 +187,7 @@ function getBinaryAssetName(binaryBaseName, platform, arch, libc) {
   if (platform === "win32") {
     return `${binaryBaseName}-win32-${mappedArch}${ext}`;
   }
-  throw new Error(`Unsupported platform: ${platform}`);
+  throw new import_primordials.ErrorCtor(`Unsupported platform: ${platform}`);
 }
 function getBinaryName(binaryBaseName, platform) {
   return platform === "win32" ? `${binaryBaseName}.exe` : binaryBaseName;
@@ -195,11 +195,11 @@ function getBinaryName(binaryBaseName, platform) {
 function getPlatformArch(platform, arch, libc) {
   const mappedPlatform = PLATFORM_MAP[platform];
   if (!mappedPlatform) {
-    throw new Error(`Unsupported platform: ${platform}`);
+    throw new import_primordials.ErrorCtor(`Unsupported platform: ${platform}`);
   }
   const mappedArch = ARCH_MAP[arch];
   if (!mappedArch) {
-    throw new Error(`Unsupported architecture: ${arch}`);
+    throw new import_primordials.ErrorCtor(`Unsupported architecture: ${arch}`);
   }
   const muslSuffix = platform === "linux" && libc === "musl" ? "-musl" : "";
   return `${mappedPlatform}-${mappedArch}${muslSuffix}`;

package/dist/schema/parse.js

@@ -24,13 +24,14 @@ __export(parse_exports, {
 });
 module.exports = __toCommonJS(parse_exports);
 var import_validate = require("./validate");
+var import_primordials = require("../primordials");
 function parseSchema(schema, data) {
   const result = (0, import_validate.validateSchema)(schema, data);
   if (result.ok) {
     return result.value;
   }
   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}`);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/schema/validate.js

@@ -23,11 +23,12 @@ __export(validate_exports, {
   validateSchema: () => validateSchema
 });
 module.exports = __toCommonJS(validate_exports);
+var import_primordials = require("../primordials");
 function isTypeBoxSchema(schema) {
   if (schema === null || typeof schema !== "object") {
     return false;
   }
-  for (const sym of Object.getOwnPropertySymbols(schema)) {
+  for (const sym of (0, import_primordials.ObjectGetOwnPropertySymbols)(schema)) {
     if (sym.description === "TypeBox.Kind") {
       return typeof schema[sym] === "string";
     }
@@ -41,7 +42,7 @@ function normalizeTypeBoxErrors(errors) {
     out.push({
       path: segs.map((s) => {
         const n = Number(s);
-        return Number.isInteger(n) && String(n) === s ? n : s;
+        return (0, import_primordials.NumberIsInteger)(n) && String(n) === s ? n : s;
       }),
       message: err.message
     });
@@ -53,13 +54,13 @@ function normalizeZodError(err) {
     return [{ path: [], message: String(err) }];
   }
   const issues = err.issues;
-  if (!Array.isArray(issues)) {
+  if (!(0, import_primordials.ArrayIsArray)(issues)) {
     return [{ path: [], message: "Unknown validation error" }];
   }
   return issues.map((issue) => {
     const i = issue;
     return {
-      path: Array.isArray(i.path) ? i.path : [],
+      path: (0, import_primordials.ArrayIsArray)(i.path) ? i.path : [],
       message: typeof i.message === "string" ? i.message : "Invalid value"
     };
   });
@@ -88,7 +89,7 @@ function validateSchema(schema, data) {
       errors: normalizeZodError(result.error)
     };
   }
-  throw new TypeError(
+  throw new import_primordials.TypeErrorCtor(
     "validateSchema: unsupported schema kind. Expected a Zod schema or an object with a safeParse method."
   );
 }

package/dist/sea/util.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @fileoverview SEA (Single Executable Application) binary detection +
+ * path accessor.
+ *
+ * Two responsibilities (mirror of `src/smol/util.ts` shape):
+ *
+ *   1. `isSeaBinary()` — memoized boolean detector for whether the
+ *      current process is running as a Node.js Single Executable
+ *      Application. Probes via Node 24+'s `node:sea.isSea()` native
+ *      API; falls back to `false` on older runtimes.
+ *
+ *   2. `getSeaBinaryPath()` — returns the path of the SEA binary
+ *      (`process.argv[0]` normalized) when running as SEA, otherwise
+ *      `undefined`.
+ *
+ * Defensive across runtimes: returns `false` / `undefined` cleanly on
+ * stock Node < 24, browsers, Deno, Bun.
+ */
+/**
+ * Detect if the current process is running as a SEA binary.
+ * Uses Node.js 24+ native API with caching for performance.
+ *
+ * @example
+ * ```typescript
+ * if (isSeaBinary()) {
+ *   console.log('Running as a Single Executable Application')
+ * }
+ * ```
+ */
+export declare function isSeaBinary(): boolean;
+/**
+ * Get the current SEA binary path.
+ * Only valid when running as a SEA binary.
+ *
+ * @example
+ * ```typescript
+ * const binPath = getSeaBinaryPath()
+ * if (binPath) {
+ *   console.log(`Running as SEA binary: ${binPath}`)
+ * }
+ * ```
+ */
+export declare function getSeaBinaryPath(): string | undefined;

package/dist/{sea.js → sea/util.js}

@@ -28,18 +28,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var sea_exports = {};
-__export(sea_exports, {
+var util_exports = {};
+__export(util_exports, {
   getSeaBinaryPath: () => getSeaBinaryPath,
   isSeaBinary: () => isSeaBinary
 });
-module.exports = __toCommonJS(sea_exports);
+module.exports = __toCommonJS(util_exports);
 var import_node_process = __toESM(require("node:process"));
-var import_normalize = require("./paths/normalize");
+var import_normalize = require("../paths/normalize");
 let _isSea;
-function getSeaBinaryPath() {
-  return isSeaBinary() && import_node_process.default.argv[0] ? (0, import_normalize.normalizePath)(import_node_process.default.argv[0]) : void 0;
-}
 function isSeaBinary() {
   if (_isSea === void 0) {
     try {
@@ -51,6 +48,9 @@ function isSeaBinary() {
   }
   return _isSea ?? false;
 }
+function getSeaBinaryPath() {
+  return isSeaBinary() && import_node_process.default.argv[0] ? (0, import_normalize.normalizePath)(import_node_process.default.argv[0]) : void 0;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getSeaBinaryPath,

package/dist/shadow.js

@@ -44,7 +44,8 @@ function shouldSkipShadow(binPath, options) {
     return true;
   }
   const userAgent = import_node_process.default.env["npm_config_user_agent"];
-  if (userAgent?.includes("exec") || userAgent?.includes("npx") || userAgent?.includes("dlx")) {
+  if (userAgent?.includes("exec") || userAgent?.includes("npx") || // # socket-hook: allow npx
+  userAgent?.includes("dlx")) {
     return true;
   }
   const normalizedCwd = (0, import_normalize.normalizePath)(cwd);

package/dist/signal-exit.js

@@ -133,7 +133,7 @@ function processReallyExit(code) {
     globalProcess,
     [exitCode]
   );
-  throw new Error("processReallyExit should never return");
+  throw new import_primordials.ErrorCtor("processReallyExit should never return");
 }
 // @__NO_SIDE_EFFECTS__
 function load() {
@@ -168,7 +168,7 @@ function onExit(cb, options) {
     };
   }
   if (typeof cb !== "function") {
-    throw new TypeError("a callback must be provided for exit handler");
+    throw new import_primordials.TypeErrorCtor("a callback must be provided for exit handler");
   }
   if (loaded === false) {
     /* @__PURE__ */ load();

package/dist/smol/primordial.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @fileoverview Lazy-loader for socket-btm's `node:smol-primordial`
+ * binding.
+ *
+ * `node:smol-primordial` provides V8 Fast API typed implementations
+ * of Math.* and Number.is* primordials, registered with
+ * `CFunction::Make()` so TurboFan inlines them directly into JIT-
+ * compiled JS callers. Bypasses the FunctionCallbackInfo trampoline
+ * entirely — ~30-50% gain on hot loops where V8 doesn't already
+ * auto-inline.
+ *
+ * Returns `undefined` on stock Node + non-Node runtimes. Result is
+ * cached across calls.
+ *
+ * @internal — used by `src/primordials.ts` to resolve smol-aware
+ *   Math.* / Number.is* fast paths. Most callers should use the
+ *   standard `primordials` exports, which already route through this
+ *   when smol is present.
+ *
+ * @see https://v8.dev/blog/v8-release-99 — V8 Fast API Calls overview
+ */
+/**
+ * Surface of `node:smol-primordial`. See socket-btm's
+ * additions/source-patched/lib/smol-primordial.js for the canonical
+ * shape.
+ *
+ * Each entry is registered as a `v8::CFunction` so V8 can inline the
+ * C++ implementation directly into JIT-compiled callers — eliminating
+ * the FunctionCallbackInfo allocation, the HandleScope, and the call-
+ * site trampoline. See the C++ binding file for which signatures
+ * get real wins (and which don't).
+ */
+export interface SmolPrimordialBinding {
+    arrayIsArray(v: unknown): v is unknown[];
+    dateNow(): number;
+    mathAbs(x: number): number;
+    mathAcos(x: number): number;
+    mathAcosh(x: number): number;
+    mathAsin(x: number): number;
+    mathAsinh(x: number): number;
+    mathAtan(x: number): number;
+    mathAtan2(a: number, b: number): number;
+    mathAtanh(x: number): number;
+    mathCbrt(x: number): number;
+    mathCeil(x: number): number;
+    mathClz32(v: number): number;
+    mathCos(x: number): number;
+    mathCosh(x: number): number;
+    mathExp(x: number): number;
+    mathExpm1(x: number): number;
+    mathFloor(x: number): number;
+    mathFround(x: number): number;
+    mathHypot(a: number, b: number): number;
+    mathImul(a: number, b: number): number;
+    mathLog(x: number): number;
+    mathLog1p(x: number): number;
+    mathLog2(x: number): number;
+    mathLog10(x: number): number;
+    mathPow(a: number, b: number): number;
+    mathRound(x: number): number;
+    mathSign(x: number): number;
+    mathSin(x: number): number;
+    mathSinh(x: number): number;
+    mathSqrt(x: number): number;
+    mathTan(x: number): number;
+    mathTanh(x: number): number;
+    mathTrunc(x: number): number;
+    numberIsFinite(v: unknown): boolean;
+    numberIsInteger(v: unknown): boolean;
+    numberIsNaN(v: unknown): boolean;
+    numberIsSafeInteger(v: unknown): boolean;
+    numberParseFloat(s: string): number;
+    numberParseInt10(s: string): number;
+    stringCharCodeAt(s: string, i: number): number;
+}
+/**
+ * Returns `node:smol-primordial` when running on the smol Node
+ * binary, otherwise `undefined`. Result is cached across calls.
+ */
+export declare function getSmolPrimordial(): SmolPrimordialBinding | undefined;

package/dist/smol/primordial.js

@@ -0,0 +1,46 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var primordial_exports = {};
+__export(primordial_exports, {
+  getSmolPrimordial: () => getSmolPrimordial
+});
+module.exports = __toCommonJS(primordial_exports);
+var import_util = require("./util");
+let _smolPrimordial;
+// @__NO_SIDE_EFFECTS__
+function getSmolPrimordial() {
+  if (_smolPrimordial === void 0) {
+    if ((0, import_util.isSmol)()) {
+      try {
+        _smolPrimordial = require("node:smol-primordial");
+      } catch {
+        _smolPrimordial = null;
+      }
+    } else {
+      _smolPrimordial = null;
+    }
+  }
+  return _smolPrimordial ?? void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSmolPrimordial
+});