@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/objects/inspect.js

@@ -1,59 +1,92 @@
 "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 inspect_exports = {};
-__export(inspect_exports, {
-  getKeys: () => getKeys,
-  getOwn: () => getOwn,
-  getOwnPropertyValues: () => getOwnPropertyValues
-});
-module.exports = __toCommonJS(inspect_exports);
-var import_object = require("../primordials/object");
-var import_predicates = require("./predicates");
-// @__NO_SIDE_EFFECTS__
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_object = require('../primordials/object.js');
+const require_objects_predicates = require('./predicates.js');
+
+//#region src/objects/inspect.ts
+/**
+* @file Object inspection helpers — `getKeys`, `getOwn`,
+*   `getOwnPropertyValues`. Safe accessors that return empty / undefined on
+*   null inputs instead of throwing.
+*/
+/**
+* Get the enumerable own property keys of an object.
+*
+* This is a safe wrapper around `Object.keys()` that returns an empty array for
+* non-object values instead of throwing an error.
+*
+* @example
+*   ;```ts
+*   getKeys({ a: 1, b: 2 }) // ['a', 'b']
+*   getKeys([10, 20, 30]) // ['0', '1', '2']
+*   getKeys(null) // []
+*   getKeys('hello') // []
+*   ```
+*
+* @param obj - The value to get keys from.
+*
+* @returns Array of enumerable string keys, or empty array for non-objects
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function getKeys(obj) {
-  return (0, import_predicates.isObject)(obj) ? (0, import_object.ObjectKeys)(obj) : [];
+	return /* @__PURE__ */ require_objects_predicates.isObject(obj) ? require_primordials_object.ObjectKeys(obj) : [];
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Get an own property value from an object safely.
+*
+* Returns `undefined` if the value is null/undefined or if the property doesn't
+* exist as an own property (not inherited). This avoids prototype chain lookups
+* and prevents errors on null/undefined values.
+*
+* @example
+*   ;```ts
+*   const obj = { name: 'Alice', age: 30 }
+*   getOwn(obj, 'name') // 'Alice'
+*   getOwn(obj, 'missing') // undefined
+*   getOwn(obj, 'toString') // undefined (inherited)
+*   getOwn(null, 'name') // undefined
+*   ```
+*
+* @param obj - The object to get the property from.
+* @param propKey - The property key to look up.
+*
+* @returns The property value, or `undefined` if not found or obj is
+*   null/undefined.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function getOwn(obj, propKey) {
-  if (obj === null || obj === void 0) {
-    return void 0;
-  }
-  return (0, import_object.ObjectHasOwn)(obj, propKey) ? obj[propKey] : void 0;
+	if (obj === null || obj === void 0) return;
+	return require_primordials_object.ObjectHasOwn(obj, propKey) ? obj[propKey] : void 0;
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Get all own property values from an object.
+*
+* Returns values for all own properties (enumerable and non-enumerable), but
+* not inherited properties. Returns an empty array for null/undefined.
+*
+* @example
+*   ;```ts
+*   getOwnPropertyValues({ a: 1, b: 2, c: 3 }) // [1, 2, 3]
+*   getOwnPropertyValues([10, 20, 30]) // [10, 20, 30]
+*   getOwnPropertyValues(null) // []
+*   ```
+*
+* @param obj - The object to get values from.
+*
+* @returns Array of all own property values, or empty array for null/undefined
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function getOwnPropertyValues(obj) {
-  if (obj === null || obj === void 0) {
-    return [];
-  }
-  const keys = (0, import_object.ObjectGetOwnPropertyNames)(obj);
-  const { length } = keys;
-  const values = Array(length);
-  for (let i = 0; i < length; i += 1) {
-    values[i] = obj[keys[i]];
-  }
-  return values;
+	if (obj === null || obj === void 0) return [];
+	const keys = require_primordials_object.ObjectGetOwnPropertyNames(obj);
+	const { length } = keys;
+	const values = Array(length);
+	for (let i = 0; i < length; i += 1) values[i] = obj[keys[i]];
+	return values;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getKeys,
-  getOwn,
-  getOwnPropertyValues
-});
+
+//#endregion
+exports.getKeys = getKeys;
+exports.getOwn = getOwn;
+exports.getOwnPropertyValues = getOwnPropertyValues;

package/dist/objects/mutate.js

@@ -1,81 +1,101 @@
 "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 mutate_exports = {};
-__export(mutate_exports, {
-  merge: () => merge,
-  objectAssign: () => objectAssign,
-  objectFreeze: () => objectFreeze
-});
-module.exports = __toCommonJS(mutate_exports);
-var import_sentinels = require("../constants/sentinels");
-var import_predicates = require("../arrays/predicates");
-var import_error = require("../primordials/error");
-var import_reflect = require("../primordials/reflect");
-var import_predicates2 = require("./predicates");
-// @__NO_SIDE_EFFECTS__
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_error = require('../primordials/error.js');
+const require_constants_sentinels = require('../constants/sentinels.js');
+const require_primordials_reflect = require('../primordials/reflect.js');
+const require_arrays_predicates = require('../arrays/predicates.js');
+const require_objects_predicates = require('./predicates.js');
+
+//#region src/objects/mutate.ts
+/**
+* @file Object mutation helpers — `merge` (deep recursive), `objectAssign`
+*   (alias for native), `objectFreeze` (alias for native). `merge` includes
+*   infinite-loop detection via `LOOP_SENTINEL` because `__proto__` and
+*   self-referential graphs would otherwise blow the stack on a recursive
+*   descent.
+*/
+/**
+* Deep merge source object into target object.
+*
+* Recursively merges properties from `source` into `target`. Arrays in source
+* completely replace arrays in target (no element-wise merging). Objects are
+* merged recursively. Includes infinite loop detection for safety.
+*
+* @example
+*   ;```ts
+*   merge(
+*     { config: { api: 'v1', timeout: 1000 } },
+*     { config: { api: 'v2', retries: 3 } },
+*   )
+*   // { config: { api: 'v2', timeout: 1000, retries: 3 } }
+*   ```
+*
+* @example
+*   ;```ts
+*   // Arrays are replaced, not merged
+*   merge({ arr: [1, 2] }, { arr: [3] }) // { arr: [3] }
+*   ```
+*
+* @param target - The object to merge into (will be modified)
+* @param source - The object to merge from.
+*
+* @returns The modified target object
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function merge(target, source) {
-  if (!(0, import_predicates2.isObject)(target) || !(0, import_predicates2.isObject)(source)) {
-    return target;
-  }
-  const queue = [[target, source]];
-  let pos = 0;
-  let { length: queueLength } = queue;
-  while (pos < queueLength) {
-    if (pos === import_sentinels.LOOP_SENTINEL) {
-      throw new import_error.ErrorCtor("Detected infinite loop in object crawl of merge");
-    }
-    const { 0: currentTarget, 1: currentSource } = queue[pos++];
-    if (!currentSource || !currentTarget) {
-      continue;
-    }
-    const isSourceArray = (0, import_predicates.isArray)(currentSource);
-    const isTargetArray = (0, import_predicates.isArray)(currentTarget);
-    if (isSourceArray || isTargetArray) {
-      continue;
-    }
-    const keys = (0, import_reflect.ReflectOwnKeys)(currentSource);
-    for (let i = 0, { length } = keys; i < length; i += 1) {
-      const key = keys[i];
-      const srcVal = currentSource[key];
-      const targetVal = currentTarget[key];
-      if ((0, import_predicates.isArray)(srcVal)) {
-        currentTarget[key] = srcVal;
-      } else if ((0, import_predicates2.isObject)(srcVal)) {
-        if ((0, import_predicates2.isObject)(targetVal) && !(0, import_predicates.isArray)(targetVal)) {
-          queue[queueLength++] = [targetVal, srcVal];
-        } else {
-          currentTarget[key] = srcVal;
-        }
-      } else {
-        currentTarget[key] = srcVal;
-      }
-    }
-  }
-  return target;
+	if (!/* @__PURE__ */ require_objects_predicates.isObject(target) || !/* @__PURE__ */ require_objects_predicates.isObject(source)) return target;
+	const queue = [[target, source]];
+	let pos = 0;
+	let { length: queueLength } = queue;
+	while (pos < queueLength) {
+		if (pos === 1e6) throw new require_primordials_error.ErrorCtor("Detected infinite loop in object crawl of merge");
+		const { 0: currentTarget, 1: currentSource } = queue[pos++];
+		if (!currentSource || !currentTarget) continue;
+		const isSourceArray = require_arrays_predicates.isArray(currentSource);
+		const isTargetArray = require_arrays_predicates.isArray(currentTarget);
+		if (isSourceArray || isTargetArray) continue;
+		const keys = require_primordials_reflect.ReflectOwnKeys(currentSource);
+		for (let i = 0, { length } = keys; i < length; i += 1) {
+			const key = keys[i];
+			const srcVal = currentSource[key];
+			const targetVal = currentTarget[key];
+			if (require_arrays_predicates.isArray(srcVal)) currentTarget[key] = srcVal;
+			else if (/* @__PURE__ */ require_objects_predicates.isObject(srcVal)) if (/* @__PURE__ */ require_objects_predicates.isObject(targetVal) && !require_arrays_predicates.isArray(targetVal)) queue[queueLength++] = [targetVal, srcVal];
+			else currentTarget[key] = srcVal;
+			else currentTarget[key] = srcVal;
+		}
+	}
+	return target;
 }
+/**
+* Alias for native `Object.assign`.
+*
+* Copies all enumerable own properties from one or more source objects to a
+* target object and returns the modified target object.
+*
+* @example
+*   ;```ts
+*   objectAssign({ a: 1 }, { b: 2 }) // { a: 1, b: 2 }
+*   ```
+*/
 const objectAssign = Object.assign;
+/**
+* Alias for native `Object.freeze`.
+*
+* Freezes an object, preventing new properties from being added and existing
+* properties from being removed or modified. Makes the object immutable.
+*
+* @example
+*   ;```ts
+*   const obj = { a: 1 }
+*   objectFreeze(obj)
+*   obj.a = 2 // Silently fails (or throws in strict mode)
+*   ```
+*/
 const objectFreeze = Object.freeze;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  merge,
-  objectAssign,
-  objectFreeze
-});
+
+//#endregion
+exports.merge = merge;
+exports.objectAssign = objectAssign;
+exports.objectFreeze = objectFreeze;

package/dist/objects/predicates.js

@@ -1,68 +1,121 @@
 "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 predicates_exports = {};
-__export(predicates_exports, {
-  hasKeys: () => hasKeys,
-  hasOwn: () => hasOwn,
-  isObject: () => isObject,
-  isPlainObject: () => isPlainObject
-});
-module.exports = __toCommonJS(predicates_exports);
-var import_predicates = require("../arrays/predicates");
-var import_object = require("../primordials/object");
-// @__NO_SIDE_EFFECTS__
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_object = require('../primordials/object.js');
+const require_arrays_predicates = require('../arrays/predicates.js');
+
+//#region src/objects/predicates.ts
+/**
+* @file Object type guards: `hasKeys`, `hasOwn`, `isObject`, `isPlainObject`.
+*   All four narrow `unknown` to a typed shape and tolerate `null` /
+*   `undefined` without throwing.
+*/
+/**
+* Check if an object has any enumerable own properties.
+*
+* Returns `true` if the object has at least one enumerable own property,
+* `false` otherwise. Also returns `false` for null/undefined.
+*
+* @example
+*   ;```ts
+*   hasKeys({ a: 1 }) // true
+*   hasKeys({}) // false
+*   hasKeys([]) // false
+*   hasKeys([1, 2]) // true
+*   hasKeys(null) // false
+*   hasKeys(undefined) // false
+*   hasKeys(Object.create({ inherited: true })) // false
+*   ```
+*
+* @param obj - The value to check.
+*
+* @returns `true` if obj has enumerable own properties, `false` otherwise
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function hasKeys(obj) {
-  if (obj === null || obj === void 0) {
-    return false;
-  }
-  for (const key in obj) {
-    if ((0, import_object.ObjectHasOwn)(obj, key)) {
-      return true;
-    }
-  }
-  return false;
+	if (obj === null || obj === void 0) return false;
+	for (const key in obj) if (require_primordials_object.ObjectHasOwn(obj, key)) return true;
+	return false;
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Check if an object has an own property.
+*
+* Type-safe wrapper around `Object.hasOwn()` that returns `false` for
+* null/undefined instead of throwing. Only checks own properties, not inherited
+* ones from the prototype chain.
+*
+* @example
+*   ;```ts
+*   const obj = { name: 'Alice' }
+*   hasOwn(obj, 'name') // true
+*   hasOwn(obj, 'age') // false
+*   hasOwn(obj, 'toString') // false (inherited)
+*   hasOwn(null, 'name') // false
+*   ```
+*
+* @param obj - The value to check.
+* @param propKey - The property key to look for.
+*
+* @returns `true` if obj has the property as an own property, `false` otherwise
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function hasOwn(obj, propKey) {
-  if (obj === null || obj === void 0) {
-    return false;
-  }
-  return (0, import_object.ObjectHasOwn)(obj, propKey);
+	if (obj === null || obj === void 0) return false;
+	return require_primordials_object.ObjectHasOwn(obj, propKey);
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Check if a value is an object (including arrays).
+*
+* Returns `true` for any object type including arrays, dates, etc. Returns
+* `false` for primitives and `null`. Functions are not considered objects here
+* (typeof functions === 'function').
+*
+* @example
+*   ;```ts
+*   isObject({}) // true
+*   isObject([]) // true
+*   isObject(new Date()) // true
+*   isObject(() => {}) // false
+*   isObject(null) // false
+*   ```
+*
+* @param value - The value to check.
+*
+* @returns `true` if value is an object (including arrays), `false` otherwise
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function isObject(value) {
-  return value !== null && typeof value === "object";
+	return value !== null && typeof value === "object";
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Check if a value is a plain object (not an array, not a built-in).
+*
+* Returns `true` only for plain objects created with `{}` or
+* `Object.create(null)`. Returns `false` for arrays, built-in objects (Date,
+* RegExp, etc.), and primitives.
+*
+* @example
+*   ;```ts
+*   isPlainObject({}) // true
+*   isPlainObject({ a: 1 }) // true
+*   isPlainObject(Object.create(null)) // true
+*   isPlainObject([]) // false
+*   isPlainObject(new Date()) // false
+*   ```
+*
+* @param value - The value to check.
+*
+* @returns `true` if value is a plain object, `false` otherwise
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function isPlainObject(value) {
-  if (value === null || typeof value !== "object" || (0, import_predicates.isArray)(value)) {
-    return false;
-  }
-  const proto = (0, import_object.ObjectGetPrototypeOf)(value);
-  return proto === null || proto === import_object.ObjectPrototype;
+	if (value === null || typeof value !== "object" || require_arrays_predicates.isArray(value)) return false;
+	const proto = require_primordials_object.ObjectGetPrototypeOf(value);
+	return proto === null || proto === require_primordials_object.ObjectPrototype;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  hasKeys,
-  hasOwn,
-  isObject,
-  isPlainObject
-});
+
+//#endregion
+exports.hasKeys = hasKeys;
+exports.hasOwn = hasOwn;
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;