@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/objects/getters.d.ts

@@ -0,0 +1,116 @@
+/**
+ * @file Lazy-getter primitives + `createConstantsObject`.
+ *   `createConstantsObject` is the most-used factory in this module — fleet
+ *   repos use it to assemble frozen settings objects with a mix of eager
+ *   values, lazy-computed values, and internals reachable through
+ *   `kInternalsSymbol`. The `defineLazyGetter*` helpers underneath are the
+ *   building blocks; `createLazyGetter` is the memoizing primitive. Cycle:
+ *   `defineLazyGetters` → `defineLazyGetter` → `defineGetter` +
+ *   `createLazyGetter`. All function-only references, no eager top- level
+ *   evaluation between siblings, so ESM tolerates.
+ */
+import type { ConstantsObjectOptions, GetterDefObj, LazyGetterStats } from './types';
+/**
+ * Create a frozen constants object with lazy getters and internal properties.
+ *
+ * This function creates an immutable object with: - Regular properties from
+ * `props` - Lazy getters that compute values on first access - Internal
+ * properties accessible via `kInternalsSymbol` - Mixin properties (lower
+ * priority, won't override existing) - Alphabetically sorted keys for
+ * consistency.
+ *
+ * The resulting object is deeply frozen and cannot be modified.
+ *
+ * @example
+ *   ;```ts
+ *   const config = createConstantsObject(
+ *     { apiUrl: 'https://api.example.com' },
+ *     {
+ *       getters: { client: () => new APIClient() },
+ *       internals: { version: '1.0.0' },
+ *     },
+ *   )
+ *   console.log(config.apiUrl) // 'https://api.example.com'
+ *   console.log(config.client) // APIClient (lazy)
+ *   console.log(config[kInternalsSymbol].version) // '1.0.0'
+ *   ```
+ *
+ * @param props - Regular properties to include on the object.
+ * @param options_ - Configuration options.
+ *
+ * @returns A frozen object with all specified properties
+ */
+export declare function createConstantsObject(props: object, options_?: ConstantsObjectOptions | undefined): Readonly<object>;
+/**
+ * Create a lazy getter function that memoizes its result.
+ *
+ * The returned function will only call the getter once, caching the result for
+ * subsequent calls. This is useful for expensive computations or operations
+ * that should only happen when needed.
+ *
+ * @example
+ *   ;```ts
+ *   const stats = { initialized: new Set() }
+ *   const getLargeData = createLazyGetter('data', () => expensive(), stats)
+ *   getLargeData() // Computes and caches
+ *   getLargeData() // Returns cached
+ *   stats.initialized.has('data') // true
+ *   ```
+ *
+ * @param name - The property key name for the getter (used for debugging and
+ *   stats)
+ * @param getter - Function that computes the value on first access.
+ * @param stats - Optional stats object to track initialization.
+ *
+ * @returns A memoized getter function
+ */
+export declare function createLazyGetter<T>(name: PropertyKey, getter: () => T, stats?: LazyGetterStats | undefined): () => T;
+/**
+ * Define a getter property on an object.
+ *
+ * The getter is non-enumerable and configurable, meaning it won't show up in
+ * `for...in` loops or `Object.keys()`, but can be redefined later.
+ *
+ * @example
+ *   ;```ts
+ *   const obj = {}
+ *   defineGetter(obj, 'timestamp', () => Date.now())
+ *   obj.timestamp // Current timestamp (computed each access)
+ *   Object.keys(obj) // [] (non-enumerable)
+ *   ```
+ *
+ * @param object - The object to define the getter on.
+ * @param propKey - The property key for the getter.
+ * @param getter - Function that computes the property value.
+ *
+ * @returns The modified object (for chaining)
+ */
+export declare function defineGetter<T>(object: object, propKey: PropertyKey, getter: () => T): object;
+/**
+ * Define a lazy getter property on an object.
+ *
+ * Unlike `defineGetter()`, this version memoizes the result so the getter
+ * function is only called once. Subsequent accesses return the cached value.
+ *
+ * @param object - The object to define the lazy getter on.
+ * @param propKey - The property key for the lazy getter.
+ * @param getter - Function that computes the value on first access.
+ * @param stats - Optional stats object to track initialization.
+ *
+ * @returns The modified object (for chaining)
+ */
+export declare function defineLazyGetter<T>(object: object, propKey: PropertyKey, getter: () => T, stats?: LazyGetterStats | undefined): object;
+/**
+ * Define multiple lazy getter properties on an object.
+ *
+ * Each getter in the provided object will be converted to a lazy getter and
+ * attached to the target object. All getters share the same stats object for
+ * tracking initialization.
+ *
+ * @param object - The object to define lazy getters on.
+ * @param getterDefObj - Object mapping property keys to getter functions.
+ * @param stats - Optional stats object to track initialization.
+ *
+ * @returns The modified object (for chaining)
+ */
+export declare function defineLazyGetters(object: object, getterDefObj: GetterDefObj | undefined, stats?: LazyGetterStats | undefined): object;

package/dist/objects/getters.js

@@ -0,0 +1,137 @@
+"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 getters_exports = {};
+__export(getters_exports, {
+  createConstantsObject: () => createConstantsObject,
+  createLazyGetter: () => createLazyGetter,
+  defineGetter: () => defineGetter,
+  defineLazyGetter: () => defineLazyGetter,
+  defineLazyGetters: () => defineLazyGetters
+});
+module.exports = __toCommonJS(getters_exports);
+var import_sentinels = require("../constants/sentinels");
+var import_map_set = require("../primordials/map-set");
+var import_object = require("../primordials/object");
+var import_reflect = require("../primordials/reflect");
+var import_sort = require("./sort");
+// @__NO_SIDE_EFFECTS__
+function createConstantsObject(props, options_) {
+  const options = { __proto__: null, ...options_ };
+  const attributes = (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    getters: options.getters ? (0, import_object.ObjectFreeze)(
+      // oxlint-disable-next-line socket/prefer-undefined-over-null -- Object.setPrototypeOf requires `null` for null-prototype objects.
+      (0, import_object.ObjectSetPrototypeOf)((0, import_sort.toSortedObject)(options.getters), null)
+    ) : void 0,
+    internals: options.internals ? (0, import_object.ObjectFreeze)(
+      // oxlint-disable-next-line socket/prefer-undefined-over-null
+      (0, import_object.ObjectSetPrototypeOf)((0, import_sort.toSortedObject)(options.internals), null)
+    ) : void 0,
+    mixin: options.mixin ? (0, import_object.ObjectFreeze)(
+      (0, import_object.ObjectDefineProperties)(
+        { __proto__: null },
+        (0, import_object.ObjectGetOwnPropertyDescriptors)(options.mixin)
+      )
+    ) : void 0,
+    props: props ? (
+      // oxlint-disable-next-line socket/prefer-undefined-over-null
+      (0, import_object.ObjectFreeze)((0, import_object.ObjectSetPrototypeOf)((0, import_sort.toSortedObject)(props), null))
+    ) : void 0
+  });
+  const lazyGetterStats = (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    initialized: new import_map_set.SetCtor()
+  });
+  const object = defineLazyGetters(
+    {
+      __proto__: null,
+      [import_sentinels.kInternalsSymbol]: (0, import_object.ObjectFreeze)({
+        __proto__: null,
+        get attributes() {
+          return attributes;
+        },
+        get lazyGetterStats() {
+          return lazyGetterStats;
+        },
+        ...attributes.internals
+      }),
+      kInternalsSymbol: import_sentinels.kInternalsSymbol,
+      ...attributes.props
+    },
+    attributes.getters,
+    lazyGetterStats
+  );
+  if (attributes.mixin) {
+    (0, import_object.ObjectDefineProperties)(
+      object,
+      (0, import_sort.toSortedObjectFromEntries)(
+        (0, import_sort.objectEntries)((0, import_object.ObjectGetOwnPropertyDescriptors)(attributes.mixin)).filter(
+          (p) => !(0, import_object.ObjectHasOwn)(object, p[0])
+        )
+      )
+    );
+  }
+  return (0, import_object.ObjectFreeze)(object);
+}
+// @__NO_SIDE_EFFECTS__
+function createLazyGetter(name, getter, stats) {
+  const UNCOMPUTED = {};
+  let lazyValue = UNCOMPUTED;
+  const { [name]: lazyGetter } = {
+    [name]() {
+      if (lazyValue === UNCOMPUTED) {
+        stats?.initialized?.add(name);
+        lazyValue = getter();
+      }
+      return lazyValue;
+    }
+  };
+  return lazyGetter;
+}
+function defineGetter(object, propKey, getter) {
+  (0, import_object.ObjectDefineProperty)(object, propKey, {
+    get: getter,
+    enumerable: false,
+    configurable: true
+  });
+  return object;
+}
+function defineLazyGetter(object, propKey, getter, stats) {
+  return defineGetter(object, propKey, /* @__PURE__ */ createLazyGetter(propKey, getter, stats));
+}
+function defineLazyGetters(object, getterDefObj, stats) {
+  if (getterDefObj !== null && typeof getterDefObj === "object") {
+    const keys = (0, import_reflect.ReflectOwnKeys)(getterDefObj);
+    for (let i = 0, { length } = keys; i < length; i += 1) {
+      const key = keys[i];
+      defineLazyGetter(object, key, getterDefObj[key], stats);
+    }
+  }
+  return object;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createConstantsObject,
+  createLazyGetter,
+  defineGetter,
+  defineLazyGetter,
+  defineLazyGetters
+});

package/dist/objects/inspect.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @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
+ */
+export declare function getKeys(obj: unknown): string[];
+/**
+ * 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.
+ */
+export declare function getOwn(obj: unknown, propKey: PropertyKey): unknown;
+/**
+ * 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
+ */
+export declare function getOwnPropertyValues<T>(obj: {
+    [key: PropertyKey]: T;
+} | null | undefined): T[];

package/dist/objects/inspect.js

@@ -0,0 +1,59 @@
+"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__
+function getKeys(obj) {
+  return (0, import_predicates.isObject)(obj) ? (0, import_object.ObjectKeys)(obj) : [];
+}
+// @__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;
+}
+// @__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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getKeys,
+  getOwn,
+  getOwnPropertyValues
+});

package/dist/objects/mutate.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @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
+ */
+export declare function merge<T extends object, U extends object>(target: T, source: U): T & U;
+/**
+ * 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 }
+ *   ```
+ */
+export declare const objectAssign: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V;
+    <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+    (target: object, ...sources: any[]): any;
+};
+/**
+ * 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)
+ *   ```
+ */
+export declare const objectFreeze: {
+    <T extends Function>(f: T): T;
+    <T extends {
+        [idx: string]: U | null | undefined | object;
+    }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>;
+    <T>(o: T): Readonly<T>;
+};

package/dist/objects/mutate.js

@@ -0,0 +1,81 @@
+"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__
+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;
+}
+const objectAssign = Object.assign;
+const objectFreeze = Object.freeze;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  merge,
+  objectAssign,
+  objectFreeze
+});

package/dist/objects/predicates.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @file Object type guards: `hasKeys`, `hasOwn`, `isObject`, `isPlainObject`.
+ *   All four narrow `unknown` to a typed shape and tolerate `null` /
+ *   `undefined` without throwing.
+ */
+import type { PropertyBag } from './types';
+/**
+ * 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
+ */
+export declare function hasKeys(obj: unknown): obj is PropertyBag;
+/**
+ * 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
+ */
+export declare function hasOwn(obj: unknown, propKey: PropertyKey): obj is object & PropertyBag;
+/**
+ * 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
+ */
+export declare function isObject(value: unknown): value is {
+    [key: PropertyKey]: unknown;
+};
+/**
+ * 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
+ */
+export declare function isPlainObject(value: unknown): value is {
+    [key: PropertyKey]: unknown;
+};