@socketsecurity/lib 5.26.1 → 5.28.0

package/dist/primordials.js

@@ -60,9 +60,12 @@ __export(primordials_exports, {
   ArrayPrototypeSplice: () => ArrayPrototypeSplice,
   ArrayPrototypeToReversed: () => ArrayPrototypeToReversed,
   ArrayPrototypeToSorted: () => ArrayPrototypeToSorted,
+  ArrayPrototypeToSpliced: () => ArrayPrototypeToSpliced,
   ArrayPrototypeUnshift: () => ArrayPrototypeUnshift,
   ArrayPrototypeValues: () => ArrayPrototypeValues,
+  ArrayPrototypeWith: () => ArrayPrototypeWith,
   AtomicsWait: () => AtomicsWait,
+  BigIntCtor: () => BigIntCtor,
   BooleanCtor: () => BooleanCtor,
   BufferAlloc: () => BufferAlloc,
   BufferAllocUnsafe: () => BufferAllocUnsafe,
@@ -84,14 +87,19 @@ __export(primordials_exports, {
   DatePrototypeToLocaleString: () => DatePrototypeToLocaleString,
   DatePrototypeValueOf: () => DatePrototypeValueOf,
   DateUTC: () => DateUTC,
+  ErrorCaptureStackTrace: () => ErrorCaptureStackTrace,
   ErrorCtor: () => ErrorCtor,
   ErrorIsError: () => ErrorIsError,
+  ErrorPrepareStackTrace: () => ErrorPrepareStackTrace,
+  ErrorStackTraceLimit: () => ErrorStackTraceLimit,
   EvalErrorCtor: () => EvalErrorCtor,
   Float32ArrayCtor: () => Float32ArrayCtor,
   Float64ArrayCtor: () => Float64ArrayCtor,
   FunctionPrototypeApply: () => FunctionPrototypeApply,
   FunctionPrototypeBind: () => FunctionPrototypeBind,
   FunctionPrototypeCall: () => FunctionPrototypeCall,
+  FunctionPrototypeToString: () => FunctionPrototypeToString,
+  InfinityValue: () => InfinityValue,
   Int16ArrayCtor: () => Int16ArrayCtor,
   Int32ArrayCtor: () => Int32ArrayCtor,
   Int8ArrayCtor: () => Int8ArrayCtor,
@@ -110,21 +118,62 @@ __export(primordials_exports, {
   MapPrototypeSet: () => MapPrototypeSet,
   MapPrototypeValues: () => MapPrototypeValues,
   MathAbs: () => MathAbs,
+  MathAcos: () => MathAcos,
+  MathAcosh: () => MathAcosh,
+  MathAsin: () => MathAsin,
+  MathAsinh: () => MathAsinh,
+  MathAtan: () => MathAtan,
+  MathAtan2: () => MathAtan2,
+  MathAtanh: () => MathAtanh,
+  MathCbrt: () => MathCbrt,
   MathCeil: () => MathCeil,
+  MathClz32: () => MathClz32,
+  MathCos: () => MathCos,
+  MathCosh: () => MathCosh,
+  MathE: () => MathE,
+  MathExp: () => MathExp,
+  MathExpm1: () => MathExpm1,
+  MathF16round: () => MathF16round,
   MathFloor: () => MathFloor,
+  MathFround: () => MathFround,
+  MathHypot: () => MathHypot,
+  MathImul: () => MathImul,
+  MathLN10: () => MathLN10,
+  MathLN2: () => MathLN2,
+  MathLOG10E: () => MathLOG10E,
+  MathLOG2E: () => MathLOG2E,
+  MathLog: () => MathLog,
+  MathLog10: () => MathLog10,
+  MathLog1p: () => MathLog1p,
+  MathLog2: () => MathLog2,
   MathMax: () => MathMax,
   MathMin: () => MathMin,
+  MathPI: () => MathPI,
   MathPow: () => MathPow,
   MathRandom: () => MathRandom,
   MathRound: () => MathRound,
+  MathSQRT1_2: () => MathSQRT1_2,
+  MathSQRT2: () => MathSQRT2,
   MathSign: () => MathSign,
+  MathSin: () => MathSin,
+  MathSinh: () => MathSinh,
   MathSqrt: () => MathSqrt,
+  MathTan: () => MathTan,
+  MathTanh: () => MathTanh,
   MathTrunc: () => MathTrunc,
+  NaNValue: () => NaNValue,
   NumberCtor: () => NumberCtor,
+  NumberEPSILON: () => NumberEPSILON,
   NumberIsFinite: () => NumberIsFinite,
   NumberIsInteger: () => NumberIsInteger,
   NumberIsNaN: () => NumberIsNaN,
   NumberIsSafeInteger: () => NumberIsSafeInteger,
+  NumberMAX_SAFE_INTEGER: () => NumberMAX_SAFE_INTEGER,
+  NumberMAX_VALUE: () => NumberMAX_VALUE,
+  NumberMIN_SAFE_INTEGER: () => NumberMIN_SAFE_INTEGER,
+  NumberMIN_VALUE: () => NumberMIN_VALUE,
+  NumberNEGATIVE_INFINITY: () => NumberNEGATIVE_INFINITY,
+  NumberPOSITIVE_INFINITY: () => NumberPOSITIVE_INFINITY,
   NumberParseFloat: () => NumberParseFloat,
   NumberParseInt: () => NumberParseInt,
   NumberPrototypeToFixed: () => NumberPrototypeToFixed,
@@ -150,8 +199,12 @@ __export(primordials_exports, {
   ObjectKeys: () => ObjectKeys,
   ObjectPreventExtensions: () => ObjectPreventExtensions,
   ObjectPrototype: () => ObjectPrototype,
+  ObjectPrototypeDefineGetter: () => ObjectPrototypeDefineGetter,
+  ObjectPrototypeDefineSetter: () => ObjectPrototypeDefineSetter,
   ObjectPrototypeHasOwnProperty: () => ObjectPrototypeHasOwnProperty,
   ObjectPrototypeIsPrototypeOf: () => ObjectPrototypeIsPrototypeOf,
+  ObjectPrototypeLookupGetter: () => ObjectPrototypeLookupGetter,
+  ObjectPrototypeLookupSetter: () => ObjectPrototypeLookupSetter,
   ObjectPrototypePropertyIsEnumerable: () => ObjectPrototypePropertyIsEnumerable,
   ObjectPrototypeToString: () => ObjectPrototypeToString,
   ObjectPrototypeValueOf: () => ObjectPrototypeValueOf,
@@ -235,12 +288,27 @@ __export(primordials_exports, {
   StringPrototypeTrimEnd: () => StringPrototypeTrimEnd,
   StringPrototypeTrimStart: () => StringPrototypeTrimStart,
   StringRaw: () => StringRaw,
+  SymbolAsyncDispose: () => SymbolAsyncDispose,
   SymbolAsyncIterator: () => SymbolAsyncIterator,
   SymbolCtor: () => SymbolCtor,
+  SymbolDispose: () => SymbolDispose,
   SymbolFor: () => SymbolFor,
+  SymbolHasInstance: () => SymbolHasInstance,
+  SymbolIsConcatSpreadable: () => SymbolIsConcatSpreadable,
   SymbolIterator: () => SymbolIterator,
+  SymbolKeyFor: () => SymbolKeyFor,
+  SymbolMatch: () => SymbolMatch,
+  SymbolMatchAll: () => SymbolMatchAll,
+  SymbolPrototypeDescription: () => SymbolPrototypeDescription,
+  SymbolPrototypeToString: () => SymbolPrototypeToString,
+  SymbolPrototypeValueOf: () => SymbolPrototypeValueOf,
+  SymbolReplace: () => SymbolReplace,
+  SymbolSearch: () => SymbolSearch,
+  SymbolSpecies: () => SymbolSpecies,
+  SymbolSplit: () => SymbolSplit,
   SymbolToPrimitive: () => SymbolToPrimitive,
   SymbolToStringTag: () => SymbolToStringTag,
+  SymbolUnscopables: () => SymbolUnscopables,
   SyntaxErrorCtor: () => SyntaxErrorCtor,
   TypeErrorCtor: () => TypeErrorCtor,
   URIErrorCtor: () => URIErrorCtor,
@@ -268,16 +336,48 @@ __export(primordials_exports, {
   WeakSetPrototypeDelete: () => WeakSetPrototypeDelete,
   WeakSetPrototypeHas: () => WeakSetPrototypeHas,
   applyBind: () => applyBind,
+  applySafe: () => applySafe,
+  bindCall: () => bindCall,
   decodeComponent: () => decodeComponent,
   encodeComponent: () => encodeComponent,
-  uncurryThis: () => uncurryThis
+  globalThisRef: () => globalThisRef,
+  uncurryThis: () => uncurryThis,
+  weakRefSafe: () => weakRefSafe
 });
 module.exports = __toCommonJS(primordials_exports);
+var import_primordial = require("./smol/primordial");
+var import_util = require("./smol/util");
+const _smolUtil = (0, import_util.getSmolUtil)();
+const _smolPrimordial = (0, import_primordial.getSmolPrimordial)();
 const { apply, bind, call } = Function.prototype;
-const uncurryThis = bind.bind(call);
-const applyBind = bind.bind(apply);
+const uncurryThis = _smolUtil?.uncurryThis ?? bind.bind(call);
+const applyBind = _smolUtil?.applyBind ?? bind.bind(apply);
+const _applyBoundForSafe = applyBind;
+const applySafe = _smolUtil?.applySafe ?? ((fn) => {
+  const apply2 = _applyBoundForSafe(fn);
+  return (self, args) => {
+    try {
+      return apply2(self, args);
+    } catch {
+      return void 0;
+    }
+  };
+});
+const _bindCallFallback = ((fn, thisArg, ...presetArgs) => Function.prototype.bind.apply(fn, [
+  thisArg,
+  ...presetArgs
+]));
+const bindCall = _smolUtil?.bindCall ?? _bindCallFallback;
+const weakRefSafe = _smolUtil?.weakRefSafe ?? ((target) => {
+  try {
+    return new WeakRef(target);
+  } catch {
+    return void 0;
+  }
+});
 const ArrayCtor = Array;
 const ArrayBufferCtor = ArrayBuffer;
+const BigIntCtor = BigInt;
 const BooleanCtor = Boolean;
 const BufferCtor = globalThis.Buffer;
 const DataViewCtor = DataView;
@@ -314,13 +414,16 @@ const URLSearchParamsCtor = URLSearchParams;
 const WeakMapCtor = WeakMap;
 const WeakRefCtor = WeakRef;
 const WeakSetCtor = WeakSet;
+const InfinityValue = Infinity;
+const NaNValue = NaN;
+const globalThisRef = globalThis;
 const decodeComponent = globalThis.decodeURIComponent;
 const encodeComponent = globalThis.encodeURIComponent;
 const JSONParse = JSON.parse;
 const JSONStringify = JSON.stringify;
 const ArrayFrom = Array.from;
 const ArrayFromAsync = Array.fromAsync;
-const ArrayIsArray = Array.isArray;
+const ArrayIsArray = _smolPrimordial?.arrayIsArray ?? Array.isArray;
 const ArrayOf = Array.of;
 const ArrayBufferIsView = ArrayBuffer.isView;
 const AtomicsWait = Atomics.wait;
@@ -362,8 +465,12 @@ const ArrayPrototypeSort = uncurryThis(Array.prototype.sort);
 const ArrayPrototypeSplice = uncurryThis(Array.prototype.splice);
 const ArrayPrototypeToReversed = uncurryThis(Array.prototype.toReversed);
 const ArrayPrototypeToSorted = uncurryThis(Array.prototype.toSorted);
+const ArrayPrototypeToSpliced = uncurryThis(
+  Array.prototype.toSpliced
+);
 const ArrayPrototypeUnshift = uncurryThis(Array.prototype.unshift);
 const ArrayPrototypeValues = uncurryThis(Array.prototype.values);
+const ArrayPrototypeWith = uncurryThis(Array.prototype.with);
 const BufferAlloc = BufferCtor?.alloc;
 const BufferAllocUnsafe = BufferCtor?.allocUnsafe;
 const BufferAllocUnsafeSlow = BufferCtor?.allocUnsafeSlow;
@@ -374,7 +481,7 @@ const BufferIsBuffer = BufferCtor?.isBuffer;
 const BufferIsEncoding = BufferCtor?.isEncoding;
 const BufferPrototypeSlice = BufferCtor ? uncurryThis(BufferCtor.prototype.slice) : void 0;
 const BufferPrototypeToString = BufferCtor ? uncurryThis(BufferCtor.prototype.toString) : void 0;
-const DateNow = Date.now;
+const DateNow = _smolPrimordial?.dateNow ?? Date.now;
 const DateParse = Date.parse;
 const DateUTC = Date.UTC;
 const DatePrototypeGetTime = uncurryThis(Date.prototype.getTime);
@@ -384,9 +491,27 @@ const DatePrototypeToLocaleString = uncurryThis(
 );
 const DatePrototypeValueOf = uncurryThis(Date.prototype.valueOf);
 const ErrorIsError = Error.isError;
+const ErrorCaptureStackTrace = Error.captureStackTrace;
+const ErrorPrepareStackTrace = Error.prepareStackTrace;
+const _stackTraceLimitGetter = (() => {
+  const getter = Error.__lookupGetter__?.("stackTraceLimit");
+  if (typeof getter === "function") {
+    return () => getter.call(Error);
+  }
+  return void 0;
+})();
+function ErrorStackTraceLimit() {
+  if (_stackTraceLimitGetter) {
+    return _stackTraceLimitGetter();
+  }
+  return Error.stackTraceLimit;
+}
 const FunctionPrototypeApply = uncurryThis(Function.prototype.apply);
 const FunctionPrototypeBind = uncurryThis(Function.prototype.bind);
 const FunctionPrototypeCall = uncurryThis(Function.prototype.call);
+const FunctionPrototypeToString = uncurryThis(
+  Function.prototype.toString
+);
 const _anyIterator = (/* @__PURE__ */ new Map()).keys();
 let _iteratorLookup = Object.getPrototypeOf(_anyIterator);
 while (_iteratorLookup && typeof _iteratorLookup.next !== "function") {
@@ -404,23 +529,64 @@ const MapPrototypeHas = uncurryThis(Map.prototype.has);
 const MapPrototypeKeys = uncurryThis(Map.prototype.keys);
 const MapPrototypeSet = uncurryThis(Map.prototype.set);
 const MapPrototypeValues = uncurryThis(Map.prototype.values);
-const MathAbs = Math.abs;
-const MathCeil = Math.ceil;
-const MathFloor = Math.floor;
+const MathE = Math.E;
+const MathLN2 = Math.LN2;
+const MathLN10 = Math.LN10;
+const MathLOG2E = Math.LOG2E;
+const MathLOG10E = Math.LOG10E;
+const MathPI = Math.PI;
+const MathSQRT1_2 = Math.SQRT1_2;
+const MathSQRT2 = Math.SQRT2;
+const MathAbs = _smolPrimordial?.mathAbs ?? Math.abs;
+const MathAcos = _smolPrimordial?.mathAcos ?? Math.acos;
+const MathAcosh = _smolPrimordial?.mathAcosh ?? Math.acosh;
+const MathAsin = _smolPrimordial?.mathAsin ?? Math.asin;
+const MathAsinh = _smolPrimordial?.mathAsinh ?? Math.asinh;
+const MathAtan = _smolPrimordial?.mathAtan ?? Math.atan;
+const MathAtan2 = _smolPrimordial?.mathAtan2 ?? Math.atan2;
+const MathAtanh = _smolPrimordial?.mathAtanh ?? Math.atanh;
+const MathCbrt = _smolPrimordial?.mathCbrt ?? Math.cbrt;
+const MathCeil = _smolPrimordial?.mathCeil ?? Math.ceil;
+const MathClz32 = _smolPrimordial?.mathClz32 ?? Math.clz32;
+const MathCos = _smolPrimordial?.mathCos ?? Math.cos;
+const MathCosh = _smolPrimordial?.mathCosh ?? Math.cosh;
+const MathExp = _smolPrimordial?.mathExp ?? Math.exp;
+const MathExpm1 = _smolPrimordial?.mathExpm1 ?? Math.expm1;
+const MathF16round = Math.f16round;
+const MathFloor = _smolPrimordial?.mathFloor ?? Math.floor;
+const MathFround = _smolPrimordial?.mathFround ?? Math.fround;
+const MathHypot = _smolPrimordial?.mathHypot ?? Math.hypot;
+const MathImul = _smolPrimordial?.mathImul ?? Math.imul;
+const MathLog = _smolPrimordial?.mathLog ?? Math.log;
+const MathLog1p = _smolPrimordial?.mathLog1p ?? Math.log1p;
+const MathLog2 = _smolPrimordial?.mathLog2 ?? Math.log2;
+const MathLog10 = _smolPrimordial?.mathLog10 ?? Math.log10;
 const MathMax = Math.max;
 const MathMin = Math.min;
-const MathPow = Math.pow;
+const MathPow = _smolPrimordial?.mathPow ?? Math.pow;
 const MathRandom = Math.random;
-const MathRound = Math.round;
-const MathSign = Math.sign;
-const MathSqrt = Math.sqrt;
-const MathTrunc = Math.trunc;
-const NumberIsFinite = Number.isFinite;
-const NumberIsInteger = Number.isInteger;
-const NumberIsNaN = Number.isNaN;
-const NumberIsSafeInteger = Number.isSafeInteger;
-const NumberParseFloat = Number.parseFloat;
-const NumberParseInt = Number.parseInt;
+const MathRound = _smolPrimordial?.mathRound ?? Math.round;
+const MathSign = _smolPrimordial?.mathSign ?? Math.sign;
+const MathSin = _smolPrimordial?.mathSin ?? Math.sin;
+const MathSinh = _smolPrimordial?.mathSinh ?? Math.sinh;
+const MathSqrt = _smolPrimordial?.mathSqrt ?? Math.sqrt;
+const MathTan = _smolPrimordial?.mathTan ?? Math.tan;
+const MathTanh = _smolPrimordial?.mathTanh ?? Math.tanh;
+const MathTrunc = _smolPrimordial?.mathTrunc ?? Math.trunc;
+const NumberEPSILON = Number.EPSILON;
+const NumberMAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+const NumberMAX_VALUE = Number.MAX_VALUE;
+const NumberMIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
+const NumberMIN_VALUE = Number.MIN_VALUE;
+const NumberNEGATIVE_INFINITY = Number.NEGATIVE_INFINITY;
+const NumberPOSITIVE_INFINITY = Number.POSITIVE_INFINITY;
+const NumberIsFinite = _smolPrimordial?.numberIsFinite ?? Number.isFinite;
+const NumberIsInteger = _smolPrimordial?.numberIsInteger ?? Number.isInteger;
+const NumberIsNaN = _smolPrimordial?.numberIsNaN ?? Number.isNaN;
+const NumberIsSafeInteger = _smolPrimordial?.numberIsSafeInteger ?? Number.isSafeInteger;
+const NumberParseFloat = _smolPrimordial?.numberParseFloat ?? Number.parseFloat;
+const _smolParseInt10 = _smolPrimordial?.numberParseInt10;
+const NumberParseInt = _smolParseInt10 ? (s, radix) => radix === void 0 || radix === 10 ? _smolParseInt10(s) : Number.parseInt(s, radix) : Number.parseInt;
 const NumberPrototypeToFixed = uncurryThis(Number.prototype.toFixed);
 const NumberPrototypeToString = uncurryThis(Number.prototype.toString);
 const ObjectAssign = Object.assign;
@@ -457,6 +623,19 @@ const ObjectPrototypePropertyIsEnumerable = uncurryThis(
 );
 const ObjectPrototypeToString = uncurryThis(Object.prototype.toString);
 const ObjectPrototypeValueOf = uncurryThis(Object.prototype.valueOf);
+const _objectProto = Object.prototype;
+const ObjectPrototypeDefineGetter = uncurryThis(
+  _objectProto.__defineGetter__
+);
+const ObjectPrototypeDefineSetter = uncurryThis(
+  _objectProto.__defineSetter__
+);
+const ObjectPrototypeLookupGetter = uncurryThis(
+  _objectProto.__lookupGetter__
+);
+const ObjectPrototypeLookupSetter = uncurryThis(
+  _objectProto.__lookupSetter__
+);
 const PromiseAll = Promise.all.bind(Promise);
 const PromiseAllSettled = Promise.allSettled.bind(Promise);
 const PromiseAny = Promise.any.bind(Promise);
@@ -502,9 +681,11 @@ const StringFromCodePoint = String.fromCodePoint;
 const StringRaw = String.raw;
 const StringPrototypeAt = uncurryThis(String.prototype.at);
 const StringPrototypeCharAt = uncurryThis(String.prototype.charAt);
-const StringPrototypeCharCodeAt = uncurryThis(
-  String.prototype.charCodeAt
-);
+const _smolCharCodeAt = _smolPrimordial?.stringCharCodeAt;
+const StringPrototypeCharCodeAt = _smolCharCodeAt ? (s, i) => {
+  const code = _smolCharCodeAt(s, i);
+  return code === -1 ? NaN : code;
+} : uncurryThis(String.prototype.charCodeAt);
 const StringPrototypeCodePointAt = uncurryThis(
   String.prototype.codePointAt
 );
@@ -556,11 +737,29 @@ const StringPrototypeToUpperCase = uncurryThis(
 const StringPrototypeTrim = uncurryThis(String.prototype.trim);
 const StringPrototypeTrimEnd = uncurryThis(String.prototype.trimEnd);
 const StringPrototypeTrimStart = uncurryThis(String.prototype.trimStart);
+const SymbolAsyncDispose = Symbol.asyncDispose;
 const SymbolAsyncIterator = Symbol.asyncIterator;
+const SymbolDispose = Symbol.dispose;
 const SymbolFor = Symbol.for;
+const SymbolHasInstance = Symbol.hasInstance;
+const SymbolIsConcatSpreadable = Symbol.isConcatSpreadable;
 const SymbolIterator = Symbol.iterator;
+const SymbolKeyFor = Symbol.keyFor;
+const SymbolMatch = Symbol.match;
+const SymbolMatchAll = Symbol.matchAll;
+const SymbolReplace = Symbol.replace;
+const SymbolSearch = Symbol.search;
+const SymbolSpecies = Symbol.species;
+const SymbolSplit = Symbol.split;
 const SymbolToPrimitive = Symbol.toPrimitive;
 const SymbolToStringTag = Symbol.toStringTag;
+const SymbolUnscopables = Symbol.unscopables;
+const _symbolDescriptionGetter = Symbol.prototype.__lookupGetter__("description");
+function SymbolPrototypeDescription(self) {
+  return _symbolDescriptionGetter ? _symbolDescriptionGetter.call(self) : self.description;
+}
+const SymbolPrototypeToString = uncurryThis(Symbol.prototype.toString);
+const SymbolPrototypeValueOf = uncurryThis(Symbol.prototype.valueOf);
 const URLSearchParamsPrototypeAppend = uncurryThis(
   URLSearchParams.prototype.append
 );
@@ -631,9 +830,12 @@ const WeakSetPrototypeHas = uncurryThis(WeakSet.prototype.has);
   ArrayPrototypeSplice,
   ArrayPrototypeToReversed,
   ArrayPrototypeToSorted,
+  ArrayPrototypeToSpliced,
   ArrayPrototypeUnshift,
   ArrayPrototypeValues,
+  ArrayPrototypeWith,
   AtomicsWait,
+  BigIntCtor,
   BooleanCtor,
   BufferAlloc,
   BufferAllocUnsafe,
@@ -655,14 +857,19 @@ const WeakSetPrototypeHas = uncurryThis(WeakSet.prototype.has);
   DatePrototypeToLocaleString,
   DatePrototypeValueOf,
   DateUTC,
+  ErrorCaptureStackTrace,
   ErrorCtor,
   ErrorIsError,
+  ErrorPrepareStackTrace,
+  ErrorStackTraceLimit,
   EvalErrorCtor,
   Float32ArrayCtor,
   Float64ArrayCtor,
   FunctionPrototypeApply,
   FunctionPrototypeBind,
   FunctionPrototypeCall,
+  FunctionPrototypeToString,
+  InfinityValue,
   Int16ArrayCtor,
   Int32ArrayCtor,
   Int8ArrayCtor,
@@ -681,21 +888,62 @@ const WeakSetPrototypeHas = uncurryThis(WeakSet.prototype.has);
   MapPrototypeSet,
   MapPrototypeValues,
   MathAbs,
+  MathAcos,
+  MathAcosh,
+  MathAsin,
+  MathAsinh,
+  MathAtan,
+  MathAtan2,
+  MathAtanh,
+  MathCbrt,
   MathCeil,
+  MathClz32,
+  MathCos,
+  MathCosh,
+  MathE,
+  MathExp,
+  MathExpm1,
+  MathF16round,
   MathFloor,
+  MathFround,
+  MathHypot,
+  MathImul,
+  MathLN10,
+  MathLN2,
+  MathLOG10E,
+  MathLOG2E,
+  MathLog,
+  MathLog10,
+  MathLog1p,
+  MathLog2,
   MathMax,
   MathMin,
+  MathPI,
   MathPow,
   MathRandom,
   MathRound,
+  MathSQRT1_2,
+  MathSQRT2,
   MathSign,
+  MathSin,
+  MathSinh,
   MathSqrt,
+  MathTan,
+  MathTanh,
   MathTrunc,
+  NaNValue,
   NumberCtor,
+  NumberEPSILON,
   NumberIsFinite,
   NumberIsInteger,
   NumberIsNaN,
   NumberIsSafeInteger,
+  NumberMAX_SAFE_INTEGER,
+  NumberMAX_VALUE,
+  NumberMIN_SAFE_INTEGER,
+  NumberMIN_VALUE,
+  NumberNEGATIVE_INFINITY,
+  NumberPOSITIVE_INFINITY,
   NumberParseFloat,
   NumberParseInt,
   NumberPrototypeToFixed,
@@ -721,8 +969,12 @@ const WeakSetPrototypeHas = uncurryThis(WeakSet.prototype.has);
   ObjectKeys,
   ObjectPreventExtensions,
   ObjectPrototype,
+  ObjectPrototypeDefineGetter,
+  ObjectPrototypeDefineSetter,
   ObjectPrototypeHasOwnProperty,
   ObjectPrototypeIsPrototypeOf,
+  ObjectPrototypeLookupGetter,
+  ObjectPrototypeLookupSetter,
   ObjectPrototypePropertyIsEnumerable,
   ObjectPrototypeToString,
   ObjectPrototypeValueOf,
@@ -806,12 +1058,27 @@ const WeakSetPrototypeHas = uncurryThis(WeakSet.prototype.has);
   StringPrototypeTrimEnd,
   StringPrototypeTrimStart,
   StringRaw,
+  SymbolAsyncDispose,
   SymbolAsyncIterator,
   SymbolCtor,
+  SymbolDispose,
   SymbolFor,
+  SymbolHasInstance,
+  SymbolIsConcatSpreadable,
   SymbolIterator,
+  SymbolKeyFor,
+  SymbolMatch,
+  SymbolMatchAll,
+  SymbolPrototypeDescription,
+  SymbolPrototypeToString,
+  SymbolPrototypeValueOf,
+  SymbolReplace,
+  SymbolSearch,
+  SymbolSpecies,
+  SymbolSplit,
   SymbolToPrimitive,
   SymbolToStringTag,
+  SymbolUnscopables,
   SyntaxErrorCtor,
   TypeErrorCtor,
   URIErrorCtor,
@@ -839,7 +1106,11 @@ const WeakSetPrototypeHas = uncurryThis(WeakSet.prototype.has);
   WeakSetPrototypeDelete,
   WeakSetPrototypeHas,
   applyBind,
+  applySafe,
+  bindCall,
   decodeComponent,
   encodeComponent,
-  uncurryThis
+  globalThisRef,
+  uncurryThis,
+  weakRefSafe
 });

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,