@socketsecurity/lib 5.25.1 → 5.26.1

package/dist/effects/shimmer.js

@@ -0,0 +1,180 @@
+"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 shimmer_exports = {};
+__export(shimmer_exports, {
+  DEFAULT_BASE_COLOR: () => DEFAULT_BASE_COLOR,
+  WHITE: () => WHITE,
+  bidirectionalSweep: () => bidirectionalSweep,
+  blendRgb: () => blendRgb,
+  blockKernel: () => blockKernel,
+  configToSpec: () => configToSpec,
+  directionToSweep: () => directionToSweep,
+  frameColors: () => frameColors,
+  gradient: () => gradient,
+  ltrSweep: () => ltrSweep,
+  noSweep: () => noSweep,
+  randomSweep: () => randomSweep,
+  resolvePalette: () => resolvePalette,
+  rtlSweep: () => rtlSweep,
+  smoothKernel: () => smoothKernel,
+  solidColor: () => solidColor
+});
+module.exports = __toCommonJS(shimmer_exports);
+var import_primordials = require("../primordials");
+const DEFAULT_BASE_COLOR = [140, 82, 255];
+const WHITE = [255, 255, 255];
+function blendRgb(a, b, t) {
+  const k = t < 0 ? 0 : t > 1 ? 1 : t;
+  return [
+    (0, import_primordials.MathRound)(a[0] + (b[0] - a[0]) * k),
+    (0, import_primordials.MathRound)(a[1] + (b[1] - a[1]) * k),
+    (0, import_primordials.MathRound)(a[2] + (b[2] - a[2]) * k)
+  ];
+}
+function gradient(palette) {
+  if (palette.length === 0) {
+    throw new import_primordials.ErrorCtor("gradient palette must not be empty");
+  }
+  return (i) => palette[i % palette.length];
+}
+function solidColor(color) {
+  return () => color;
+}
+function blockKernel(halfWidth = 1) {
+  return (d, ctx) => (0, import_primordials.MathAbs)(d) <= halfWidth ? ctx.highlightColor : ctx.baseColor;
+}
+function smoothKernel(halfWidth = 2.5, falloff = 2.5) {
+  return (d, ctx) => {
+    const dist = (0, import_primordials.MathAbs)(d);
+    if (dist >= halfWidth) {
+      return ctx.baseColor;
+    }
+    const t = (1 - dist / halfWidth) ** falloff;
+    return blendRgb(ctx.baseColor, ctx.highlightColor, t);
+  };
+}
+function bidirectionalSweep(textLength, padding = 2) {
+  const cycle = textLength + 2 * padding;
+  const fullCycle = cycle * 2;
+  return (frame) => {
+    const f = (frame % fullCycle + fullCycle) % fullCycle;
+    if (f < cycle) {
+      return f - padding;
+    }
+    return textLength + padding - 1 - (f - cycle);
+  };
+}
+function ltrSweep(textLength, padding = 2) {
+  const cycle = textLength + 2 * padding;
+  return (frame) => (frame % cycle + cycle) % cycle - padding;
+}
+function noSweep() {
+  return () => -Infinity;
+}
+function randomSweep(textLength, padding = 2, random = Math.random) {
+  const cycle = textLength + 2 * padding;
+  let dir = random() < 0.5 ? "ltr" : "rtl";
+  let lastCycleIndex = 0;
+  return (frame) => {
+    const f = (frame % (cycle * 2 ** 30) + cycle * 2 ** 30) % (cycle * 2 ** 30);
+    const cycleIndex = (0, import_primordials.MathFloor)(f / cycle);
+    if (cycleIndex !== lastCycleIndex) {
+      dir = random() < 0.5 ? "ltr" : "rtl";
+      lastCycleIndex = cycleIndex;
+    }
+    const inCycle = f % cycle;
+    return dir === "ltr" ? inCycle - padding : textLength + padding - 1 - inCycle;
+  };
+}
+function rtlSweep(textLength, padding = 2) {
+  const cycle = textLength + 2 * padding;
+  return (frame) => textLength + padding - 1 - (frame % cycle + cycle) % cycle;
+}
+function directionToSweep(dir, textLength, padding) {
+  switch (dir) {
+    case "rtl":
+      return rtlSweep(textLength, padding);
+    case "bi":
+      return bidirectionalSweep(textLength, padding);
+    case "random":
+      return randomSweep(textLength, padding);
+    case "none":
+      return noSweep();
+    default:
+      return ltrSweep(textLength, padding);
+  }
+}
+function configToSpec(config, textLength) {
+  const dir = config.dir ?? "ltr";
+  const padding = config.padding ?? 2;
+  const speed = config.speed ?? 1 / 3;
+  const baseColor = resolvePalette(config.color, DEFAULT_BASE_COLOR);
+  const highlightColor = resolvePalette(config.highlight, WHITE);
+  const kernel = config.kernel === "block" ? blockKernel(1) : smoothKernel(config.width ?? 2.5);
+  const sweep = directionToSweep(dir, textLength, padding);
+  return {
+    positionAt: (frame) => sweep(frame * speed),
+    kernel,
+    baseColor,
+    highlightColor
+  };
+}
+function resolvePalette(source, defaultColor) {
+  if (source === void 0) {
+    return solidColor(defaultColor);
+  }
+  if ((0, import_primordials.ArrayIsArray)(source[0])) {
+    return gradient(source);
+  }
+  return solidColor(source);
+}
+function frameColors(spec, textLength, frame) {
+  const wavePos = spec.positionAt(frame);
+  const out = [];
+  for (let i = 0; i < textLength; i++) {
+    const ctx = {
+      __proto__: null,
+      baseColor: spec.baseColor(i),
+      highlightColor: spec.highlightColor(i)
+    };
+    out.push(spec.kernel(i - wavePos, ctx));
+  }
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_BASE_COLOR,
+  WHITE,
+  bidirectionalSweep,
+  blendRgb,
+  blockKernel,
+  configToSpec,
+  directionToSweep,
+  frameColors,
+  gradient,
+  ltrSweep,
+  noSweep,
+  randomSweep,
+  resolvePalette,
+  rtlSweep,
+  smoothKernel,
+  solidColor
+});

package/dist/env/rewire.js

@@ -43,6 +43,7 @@ module.exports = __toCommonJS(rewire_exports);
 var import_node_process = __toESM(require("node:process"));
 var import_objects = require("../objects");
 var import_helpers = require("./helpers");
+var import_primordials = require("../primordials");
 let _async_hooks;
 // @__NO_SIDE_EFFECTS__
 function getAsyncHooks() {
@@ -59,7 +60,7 @@ const sharedOverridesSymbol = Symbol.for(
 const _globalThis = globalThis;
 const isVitestEnv = (0, import_helpers.envAsBoolean)(import_node_process.default.env["VITEST"]);
 if (isVitestEnv && !_globalThis[sharedOverridesSymbol]) {
-  _globalThis[sharedOverridesSymbol] = /* @__PURE__ */ new Map();
+  _globalThis[sharedOverridesSymbol] = new import_primordials.MapCtor();
 }
 const sharedOverrides = _globalThis[sharedOverridesSymbol];
 function clearEnv(key) {
@@ -96,11 +97,11 @@ function setEnv(key, value) {
   sharedOverrides?.set(key, value);
 }
 async function withEnv(overrides, fn) {
-  const map = new Map(Object.entries(overrides));
+  const map = new import_primordials.MapCtor((0, import_primordials.ObjectEntries)(overrides));
   return await isolatedOverridesStorage.run(map, fn);
 }
 function withEnvSync(overrides, fn) {
-  const map = new Map(Object.entries(overrides));
+  const map = new import_primordials.MapCtor((0, import_primordials.ObjectEntries)(overrides));
   return isolatedOverridesStorage.run(map, fn);
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/env.js

@@ -27,12 +27,13 @@ __export(env_exports, {
   findCaseInsensitiveEnvKey: () => findCaseInsensitiveEnvKey
 });
 module.exports = __toCommonJS(env_exports);
+var import_primordials = require("./primordials");
 const NumberCtor = Number;
 const NumberIsFinite = Number.isFinite;
 const NumberIsNaN = Number.isNaN;
 const NumberParseInt = Number.parseInt;
 const StringCtor = String;
-const caseInsensitiveKeys = /* @__PURE__ */ new Set([
+const caseInsensitiveKeys = new import_primordials.SetCtor([
   "APPDATA",
   "COMSPEC",
   "HOME",
@@ -69,7 +70,7 @@ function createEnvProxy(base, overrides) {
     }
     return void 0;
   }
-  return new Proxy({}, {
+  return new import_primordials.ProxyCtor({}, {
     get(_target, prop) {
       if (typeof prop !== "string") {
         return void 0;
@@ -168,7 +169,7 @@ function envAsNumber(value, defaultValueOrOptions = 0) {
 }
 // @__NO_SIDE_EFFECTS__
 function envAsString(value, defaultValueOrOptions = "") {
-  const isOptionsObject = typeof defaultValueOrOptions === "object" && defaultValueOrOptions !== null && !Array.isArray(defaultValueOrOptions) && ("defaultValue" in defaultValueOrOptions || "trim" in defaultValueOrOptions);
+  const isOptionsObject = typeof defaultValueOrOptions === "object" && defaultValueOrOptions !== null && !(0, import_primordials.ArrayIsArray)(defaultValueOrOptions) && ("defaultValue" in defaultValueOrOptions || "trim" in defaultValueOrOptions);
   const opts = isOptionsObject ? defaultValueOrOptions : {
     defaultValue: defaultValueOrOptions === void 0 ? "" : typeof defaultValueOrOptions === "string" ? defaultValueOrOptions : StringCtor(defaultValueOrOptions)
   };
@@ -184,7 +185,7 @@ function envAsString(value, defaultValueOrOptions = "") {
 }
 function findCaseInsensitiveEnvKey(env, upperEnvVarName) {
   const targetLength = upperEnvVarName.length;
-  for (const key of Object.keys(env)) {
+  for (const key of (0, import_primordials.ObjectKeys)(env)) {
     if (key.length !== targetLength) {
       continue;
     }

package/dist/errors.js

@@ -50,7 +50,7 @@ function isErrnoException(value) {
   if (typeof code !== "string" || code.length === 0) {
     return false;
   }
-  const first = code.charCodeAt(0);
+  const first = (0, import_primordials.StringPrototypeCharCodeAt)(code, 0);
   return first >= 65 && first <= 90;
 }
 function errorMessage(value) {

package/dist/external/@npmcli/package-json/lib/read-package.js

@@ -1,4 +1,4 @@
-const { SymbolFor: _p_SymbolFor } = require('../../../../primordials.js')
+const { ArrayIsArray: _p_ArrayIsArray, BufferIsBuffer: _p_BufferIsBuffer, JSONParse: _p_JSONParse, ObjectAssign: _p_ObjectAssign, StringPrototypeCharCodeAt: _p_StringPrototypeCharCodeAt, TypeErrorCtor: _p_TypeErrorCtor } = require('../../../../primordials.js')
 "use strict";
 /**
  * Bundled from @npmcli/package-json/lib/read-package.js
@@ -16,8 +16,8 @@ var __commonJS = (cb, mod) => function __require() {
 var require_lib = __commonJS({
   "node_modules/.pnpm/json-parse-even-better-errors@5.0.0/node_modules/json-parse-even-better-errors/lib/index.js"(exports2, module2) {
     "use strict";
-    var INDENT = _p_SymbolFor("indent");
-    var NEWLINE = _p_SymbolFor("newline");
+    var INDENT = Symbol.for("indent");
+    var NEWLINE = Symbol.for("newline");
     var DEFAULT_NEWLINE = "\n";
     var DEFAULT_INDENT = "  ";
     var BOM = /^\uFEFF/;
@@ -25,7 +25,7 @@ var require_lib = __commonJS({
     var EMPTY = /^(?:\{\}|\[\])((?:\r?\n)+)?$/;
     var UNEXPECTED_TOKEN = /^Unexpected token '?(.)'?(,)? /i;
     var hexify = /* @__PURE__ */ __name((char) => {
-      const h = char.charCodeAt(0).toString(16).toUpperCase();
+      const h = _p_StringPrototypeCharCodeAt(char, 0).toString(16).toUpperCase();
       return `0x${h.length % 2 ? "0" : ""}${h}`;
     }, "hexify");
     var stripBOM = /* @__PURE__ */ __name((txt) => String(txt).replace(BOM, ""), "stripBOM");
@@ -71,7 +71,7 @@ var require_lib = __commonJS({
       constructor(er, txt, context, caller) {
         const metadata = parseError(er, txt, context);
         super(metadata.message);
-        Object.assign(this, metadata);
+        _p_ObjectAssign(this, metadata);
         this.code = "EJSONPARSE";
         this.systemError = er;
         Error.captureStackTrace(this, caller || this.constructor);
@@ -86,7 +86,7 @@ var require_lib = __commonJS({
       }
     };
     var parseJson = /* @__PURE__ */ __name((txt, reviver) => {
-      const result = JSON.parse(txt, reviver);
+      const result = _p_JSONParse(txt, reviver);
       if (result && typeof result === "object") {
         const match = txt.match(EMPTY) || txt.match(FORMAT) || [null, "", ""];
         result[NEWLINE] = match[1] ?? DEFAULT_NEWLINE;
@@ -99,10 +99,10 @@ var require_lib = __commonJS({
       try {
         return parseJson(txt, reviver);
       } catch (e) {
-        if (typeof raw !== "string" && !Buffer.isBuffer(raw)) {
-          const msg = Array.isArray(raw) && raw.length === 0 ? "an empty array" : String(raw);
-          throw Object.assign(
-            new TypeError(`Cannot parse ${msg}`),
+        if (typeof raw !== "string" && !_p_BufferIsBuffer(raw)) {
+          const msg = _p_ArrayIsArray(raw) && raw.length === 0 ? "an empty array" : String(raw);
+          throw _p_ObjectAssign(
+            new _p_TypeErrorCtor(`Cannot parse ${msg}`),
             { code: "EJSONPARSE", systemError: e }
           );
         }