@socketsecurity/lib 4.3.0 → 5.0.0

package/dist/json/types.d.ts

@@ -0,0 +1,229 @@
+/**
+ * @fileoverview JSON type definitions and interfaces.
+ */
+/**
+ * JSON primitive types: `null`, `boolean`, `number`, or `string`.
+ *
+ * @example
+ * ```ts
+ * const primitives: JsonPrimitive[] = [null, true, 42, 'hello']
+ * ```
+ */
+export type JsonPrimitive = null | boolean | number | string;
+/**
+ * A JSON array containing JSON values.
+ *
+ * @example
+ * ```ts
+ * const arr: JsonArray = [1, 'two', { three: 3 }, [4, 5]]
+ * ```
+ */
+export interface JsonArray extends Array<JsonValue> {
+}
+/**
+ * A JSON object with string keys and JSON values.
+ *
+ * @example
+ * ```ts
+ * const obj: JsonObject = {
+ *   name: 'example',
+ *   count: 42,
+ *   active: true,
+ *   nested: { key: 'value' }
+ * }
+ * ```
+ */
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+/**
+ * Any valid JSON value: primitive, object, or array.
+ *
+ * @example
+ * ```ts
+ * const values: JsonValue[] = [
+ *   null,
+ *   true,
+ *   42,
+ *   'hello',
+ *   { key: 'value' },
+ *   [1, 2, 3]
+ * ]
+ * ```
+ */
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+/**
+ * Reviver function for transforming parsed JSON values.
+ * Called for each key-value pair during parsing.
+ *
+ * @param key - The object key or array index being parsed
+ * @param value - The parsed value
+ * @returns The transformed value (or original if no transform needed)
+ *
+ * @example
+ * ```ts
+ * // Convert date strings to Date objects
+ * const reviver: JsonReviver = (key, value) => {
+ *   if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}/.test(value)) {
+ *     return new Date(value)
+ *   }
+ *   return value
+ * }
+ * ```
+ */
+export type JsonReviver = (key: string, value: unknown) => unknown;
+/**
+ * Options for JSON parsing operations.
+ */
+export interface JsonParseOptions {
+    /**
+     * Optional filepath for improved error messages.
+     * When provided, errors will be prefixed with the filepath.
+     *
+     * @example
+     * ```ts
+     * // Error message will be: "config.json: Unexpected token } in JSON"
+     * jsonParse('invalid', { filepath: 'config.json' })
+     * ```
+     */
+    filepath?: string | undefined;
+    /**
+     * Optional reviver function to transform parsed values.
+     * Called for each key-value pair during parsing.
+     *
+     * @example
+     * ```ts
+     * // Convert ISO date strings to Date objects
+     * const options = {
+     *   reviver: (key, value) => {
+     *     if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}/.test(value)) {
+     *       return new Date(value)
+     *     }
+     *     return value
+     *   }
+     * }
+     * ```
+     */
+    reviver?: JsonReviver | undefined;
+    /**
+     * Whether to throw on parse errors.
+     * When `false`, returns `undefined` instead of throwing.
+     *
+     * @default true
+     *
+     * @example
+     * ```ts
+     * // Throws error
+     * jsonParse('invalid', { throws: true })
+     *
+     * // Returns undefined
+     * const result = jsonParse('invalid', { throws: false })
+     * ```
+     */
+    throws?: boolean | undefined;
+}
+/**
+ * Options for saving editable JSON files.
+ */
+export interface EditableJsonSaveOptions {
+    /**
+     * Whether to ignore whitespace-only changes when determining if save is needed.
+     * @default false
+     */
+    ignoreWhitespace?: boolean | undefined;
+    /**
+     * Whether to sort object keys alphabetically before saving.
+     * @default false
+     */
+    sort?: boolean | undefined;
+}
+/**
+ * Options for creating or loading editable JSON instances.
+ */
+export interface EditableJsonOptions<T = Record<string, unknown>> {
+    /**
+     * File path for the JSON file (optional for in-memory instances).
+     */
+    path?: string | undefined;
+    /**
+     * Whether to create the file if it doesn't exist during load.
+     * @default false
+     */
+    create?: boolean | undefined;
+    /**
+     * Initial data to populate the instance with.
+     */
+    data?: T | undefined;
+}
+/**
+ * EditableJson instance interface for JSON file manipulation.
+ * Provides core functionality for loading, editing, and saving JSON files
+ * while preserving formatting (indentation and line endings).
+ */
+export interface EditableJsonInstance<T = Record<string, unknown>> {
+    /**
+     * The parsed JSON content as a readonly object.
+     * @readonly
+     */
+    content: Readonly<T>;
+    /**
+     * Create a new JSON file at the specified path.
+     * @param path - The file path where JSON will be created
+     */
+    create(path: string): this;
+    /**
+     * Initialize the instance from a content object.
+     * Note: Disables saving when used (no file path associated).
+     * @param content - The JSON content object
+     */
+    fromContent(content: unknown): this;
+    /**
+     * Initialize the instance from a JSON string.
+     * @param json - The JSON content as a string
+     */
+    fromJSON(json: string): this;
+    /**
+     * Load a JSON file from the specified path.
+     * @param path - The file path to load
+     * @param create - Whether to create the file if it doesn't exist
+     */
+    load(path: string, create?: boolean): Promise<this>;
+    /**
+     * Update the JSON content with new values.
+     * @param content - Partial object with fields to update
+     */
+    update(content: Partial<T>): this;
+    /**
+     * Save the JSON file to disk.
+     * @param options - Save options for formatting and sorting
+     */
+    save(options?: EditableJsonSaveOptions): Promise<boolean>;
+    /**
+     * Synchronously save the JSON file to disk.
+     * @param options - Save options for formatting and sorting
+     */
+    saveSync(options?: EditableJsonSaveOptions): boolean;
+    /**
+     * Check if the JSON will be saved based on current changes.
+     * @param options - Save options to evaluate
+     */
+    willSave(options?: EditableJsonSaveOptions): boolean;
+    /**
+     * The full path to the JSON file.
+     * @readonly
+     */
+    readonly filename: string;
+    /**
+     * The directory path containing the JSON file.
+     * @readonly
+     */
+    readonly path: string | undefined;
+}
+/**
+ * EditableJson constructor interface.
+ */
+export interface EditableJsonConstructor<T = Record<string, unknown>> {
+    new (): EditableJsonInstance<T>;
+    create(path: string, opts?: EditableJsonOptions<T>): Promise<EditableJsonInstance<T>>;
+    load(path: string, opts?: EditableJsonOptions<T>): Promise<EditableJsonInstance<T>>;
+}

package/dist/json/types.js

@@ -0,0 +1,17 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/objects.d.ts

@@ -55,33 +55,6 @@ type SortedObject<T> = {
     [key: PropertyKey]: T;
 };
 export type { GetterDefObj, LazyGetterStats, ConstantsObjectOptions, Remap };
-/**
- * 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.
- *
- * @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
- *
- * @example
- * ```ts
- * const stats = { initialized: new Set() }
- * const getLargeData = createLazyGetter('data', () => {
- *   console.log('Computing expensive data...')
- *   return { large: 'dataset' }
- * }, stats)
- *
- * getLargeData() // Logs "Computing expensive data..." and returns data
- * getLargeData() // Returns cached data without logging
- * console.log(stats.initialized.has('data')) // true
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export declare function createLazyGetter<T>(name: PropertyKey, getter: () => T, stats?: LazyGetterStats | undefined): () => T;
 /**
  * Create a frozen constants object with lazy getters and internal properties.
  *
@@ -120,6 +93,33 @@ export declare function createLazyGetter<T>(name: PropertyKey, getter: () => T,
  */
 /*@__NO_SIDE_EFFECTS__*/
 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.
+ *
+ * @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
+ *
+ * @example
+ * ```ts
+ * const stats = { initialized: new Set() }
+ * const getLargeData = createLazyGetter('data', () => {
+ *   console.log('Computing expensive data...')
+ *   return { large: 'dataset' }
+ * }, stats)
+ *
+ * getLargeData() // Logs "Computing expensive data..." and returns data
+ * getLargeData() // Returns cached data without logging
+ * console.log(stats.initialized.has('data')) // true
+ * ```
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function createLazyGetter<T>(name: PropertyKey, getter: () => T, stats?: LazyGetterStats | undefined): () => T;
 /**
  * Define a getter property on an object.
  *
@@ -393,6 +393,40 @@ export declare const objectAssign: {
     <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
     (target: object, ...sources: any[]): any;
 };
+/**
+ * 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.
+ *
+ * @param target - The object to merge into (will be modified)
+ * @param source - The object to merge from
+ * @returns The modified target object
+ *
+ * @example
+ * ```ts
+ * const target = { a: { x: 1 }, b: [1, 2] }
+ * const source = { a: { y: 2 }, b: [3, 4, 5], c: 3 }
+ * merge(target, source)
+ * // { a: { x: 1, y: 2 }, b: [3, 4, 5], c: 3 }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Arrays are replaced, not merged
+ * merge({ arr: [1, 2] }, { arr: [3] }) // { arr: [3] }
+ *
+ * // Deep object merging
+ * merge(
+ *   { config: { api: 'v1', timeout: 1000 } },
+ *   { config: { api: 'v2', retries: 3 } }
+ * )
+ * // { config: { api: 'v2', timeout: 1000, retries: 3 } }
+ * ```
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function merge<T extends object, U extends object>(target: T, source: U): T & U;
 /**
  * Get all own property entries (key-value pairs) from an object.
  *
@@ -438,40 +472,6 @@ export declare const objectFreeze: {
     }, U extends string | number | bigint | symbol | boolean>(o: T): Readonly<T>;
     <T>(o: T): Readonly<T>;
 };
-/**
- * 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.
- *
- * @param target - The object to merge into (will be modified)
- * @param source - The object to merge from
- * @returns The modified target object
- *
- * @example
- * ```ts
- * const target = { a: { x: 1 }, b: [1, 2] }
- * const source = { a: { y: 2 }, b: [3, 4, 5], c: 3 }
- * merge(target, source)
- * // { a: { x: 1, y: 2 }, b: [3, 4, 5], c: 3 }
- * ```
- *
- * @example
- * ```ts
- * // Arrays are replaced, not merged
- * merge({ arr: [1, 2] }, { arr: [3] }) // { arr: [3] }
- *
- * // Deep object merging
- * merge(
- *   { config: { api: 'v1', timeout: 1000 } },
- *   { config: { api: 'v2', retries: 3 } }
- * )
- * // { config: { api: 'v2', timeout: 1000, retries: 3 } }
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export declare function merge<T extends object, U extends object>(target: T, source: U): T & U;
 /**
  * Convert an object to a new object with sorted keys.
  *

package/dist/objects.js

@@ -56,20 +56,6 @@ const ObjectPrototype = Object.prototype;
 const ObjectSetPrototypeOf = Object.setPrototypeOf;
 const ReflectOwnKeys = Reflect.ownKeys;
 // @__NO_SIDE_EFFECTS__
-function createLazyGetter(name, getter, stats) {
-  let lazyValue = import_core.UNDEFINED_TOKEN;
-  const { [name]: lazyGetter } = {
-    [name]() {
-      if (lazyValue === import_core.UNDEFINED_TOKEN) {
-        stats?.initialized?.add(name);
-        lazyValue = getter();
-      }
-      return lazyValue;
-    }
-  };
-  return lazyGetter;
-}
-// @__NO_SIDE_EFFECTS__
 function createConstantsObject(props, options_) {
   const options = { __proto__: null, ...options_ };
   const attributes = ObjectFreeze({
@@ -123,6 +109,20 @@ function createConstantsObject(props, options_) {
   }
   return ObjectFreeze(object);
 }
+// @__NO_SIDE_EFFECTS__
+function createLazyGetter(name, getter, stats) {
+  let lazyValue = import_core.UNDEFINED_TOKEN;
+  const { [name]: lazyGetter } = {
+    [name]() {
+      if (lazyValue === import_core.UNDEFINED_TOKEN) {
+        stats?.initialized?.add(name);
+        lazyValue = getter();
+      }
+      return lazyValue;
+    }
+  };
+  return lazyGetter;
+}
 function defineGetter(object, propKey, getter) {
   ObjectDefineProperty(object, propKey, {
     get: getter,
@@ -209,22 +209,6 @@ function isObjectObject(value) {
 }
 const objectAssign = Object.assign;
 // @__NO_SIDE_EFFECTS__
-function objectEntries(obj) {
-  if (obj === null || obj === void 0) {
-    return [];
-  }
-  const keys = ReflectOwnKeys(obj);
-  const { length } = keys;
-  const entries = Array(length);
-  const record = obj;
-  for (let i = 0; i < length; i += 1) {
-    const key = keys[i];
-    entries[i] = [key, record[key]];
-  }
-  return entries;
-}
-const objectFreeze = Object.freeze;
-// @__NO_SIDE_EFFECTS__
 function merge(target, source) {
   if (!/* @__PURE__ */ isObject(target) || !/* @__PURE__ */ isObject(source)) {
     return target;
@@ -266,6 +250,22 @@ function merge(target, source) {
   return target;
 }
 // @__NO_SIDE_EFFECTS__
+function objectEntries(obj) {
+  if (obj === null || obj === void 0) {
+    return [];
+  }
+  const keys = ReflectOwnKeys(obj);
+  const { length } = keys;
+  const entries = Array(length);
+  const record = obj;
+  for (let i = 0; i < length; i += 1) {
+    const key = keys[i];
+    entries[i] = [key, record[key]];
+  }
+  return entries;
+}
+const objectFreeze = Object.freeze;
+// @__NO_SIDE_EFFECTS__
 function toSortedObject(obj) {
   return /* @__PURE__ */ toSortedObjectFromEntries(/* @__PURE__ */ objectEntries(obj));
 }

package/dist/packages/{editable.js → edit.js}

@@ -27,22 +27,21 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var editable_exports = {};
-__export(editable_exports, {
+var edit_exports = {};
+__export(edit_exports, {
   getEditablePackageJsonClass: () => getEditablePackageJsonClass,
   pkgJsonToEditable: () => pkgJsonToEditable,
   toEditablePackageJson: () => toEditablePackageJson,
   toEditablePackageJsonSync: () => toEditablePackageJsonSync
 });
-module.exports = __toCommonJS(editable_exports);
+module.exports = __toCommonJS(edit_exports);
 var import_package_json = __toESM(require("../external/@npmcli/package-json"));
 var import_read_package = require("../external/@npmcli/package-json/lib/read-package");
 var import_sort = require("../external/@npmcli/package-json/lib/sort");
+var import_format = require("../json/format");
 var import_normalize = require("../paths/normalize");
 var import_normalize2 = require("./normalize");
 var import_packages = require("../paths/packages");
-const identSymbol = Symbol.for("indent");
-const newlineSymbol = Symbol.for("newline");
 let _EditablePackageJsonClass;
 let _fs;
 // @__NO_SIDE_EFFECTS__
@@ -193,35 +192,22 @@ function getEditablePackageJsonClass() {
         if (!this._canSave || this.content === void 0) {
           throw new Error("No package.json to save to");
         }
-        const { ignoreWhitespace = false, sort = false } = {
-          __proto__: null,
-          ...options
-        };
-        const {
-          [identSymbol]: indent,
-          [newlineSymbol]: newline,
-          ...rest
-        } = this.content;
-        const content = sort ? (0, import_sort.packageSort)(rest) : rest;
-        const {
-          [identSymbol]: _indent,
-          [newlineSymbol]: _newline,
-          ...origContent
-        } = this._readFileJson || {};
-        if (ignoreWhitespace && (/* @__PURE__ */ getUtil()).isDeepStrictEqual(content, origContent)) {
-          return false;
-        }
-        const format = indent === void 0 || indent === null ? "  " : indent;
-        const eol = newline === void 0 || newline === null ? "\n" : newline;
-        const fileContent = `${JSON.stringify(
-          content,
-          void 0,
-          format
-        )}
-`.replace(/\n/g, eol);
-        if (!ignoreWhitespace && fileContent.trim() === this._readFileContent.trim()) {
+        if (!(0, import_format.shouldSave)(
+          this.content,
+          this._readFileJson,
+          this._readFileContent,
+          { ...options, sortFn: options?.sort ? import_sort.packageSort : void 0 }
+        )) {
           return false;
         }
+        const content = (0, import_format.stripFormattingSymbols)(
+          this.content
+        );
+        const sortedContent = options?.sort ? (0, import_sort.packageSort)(content) : content;
+        const formatting = (0, import_format.getFormattingFromContent)(
+          this.content
+        );
+        const fileContent = (0, import_format.stringifyWithFormatting)(sortedContent, formatting);
         const { promises: fsPromises } = /* @__PURE__ */ getFs();
         await fsPromises.writeFile(this.filename, fileContent);
         this._readFileContent = fileContent;

package/dist/packages/operations.js

@@ -55,7 +55,7 @@ var import_objects = require("../objects");
 var import_normalize = require("./normalize");
 var import_packages2 = require("../paths/packages");
 var import_specs = require("./specs");
-var import_editable = require("./editable");
+var import_edit = require("./edit");
 const abortSignal = (0, import_process.getAbortSignal)();
 const packageExtensions = (0, import_packages.getPackageExtensions)();
 const packumentCache = (0, import_packages.getPackumentCache)();
@@ -161,7 +161,7 @@ async function readPackageJson(filepath, options) {
   });
   if (pkgJson) {
     if (editable) {
-      return await (0, import_editable.toEditablePackageJson)(pkgJson, {
+      return await (0, import_edit.toEditablePackageJson)(pkgJson, {
         path: filepath,
         normalize,
         ...normalizeOptions
@@ -180,7 +180,7 @@ function readPackageJsonSync(filepath, options) {
   const pkgJson = (0, import_fs.readJsonSync)((0, import_packages2.resolvePackageJsonPath)(filepath), { throws });
   if (pkgJson) {
     if (editable) {
-      return (0, import_editable.toEditablePackageJsonSync)(pkgJson, {
+      return (0, import_edit.toEditablePackageJsonSync)(pkgJson, {
         path: filepath,
         normalize,
         ...normalizeOptions

package/dist/packages.d.ts

@@ -3,7 +3,7 @@
  * Provides npm package analysis, dependency resolution, and registry operations.
  */
 import type { CategoryString } from './types';
-import { getEditablePackageJsonClass, pkgJsonToEditable, toEditablePackageJson, toEditablePackageJsonSync } from './packages/editable';
+import { getEditablePackageJsonClass, pkgJsonToEditable, toEditablePackageJson, toEditablePackageJsonSync } from './packages/edit';
 import { findTypesForSubpath, getExportFilePaths, getSubpaths, isConditionalExports, isSubpathExports, resolvePackageJsonEntryExports } from './packages/exports';
 import { isolatePackage } from './packages/isolation';
 import { collectIncompatibleLicenses, collectLicenseWarnings, createAstNode, createBinaryOperationNode, createLicenseNode, parseSpdxExp, resolvePackageLicenses, visitLicenses } from './packages/licenses';
@@ -19,7 +19,7 @@ type PackageExports = {
     [path: string]: unknown;
 };
 // Re-export the EditablePackageJson instance type for convenient access
-export type EditablePackageJson = import('./packages/editable').EditablePackageJsonInstance;
+export type EditablePackageJson = import('./packages/edit').EditablePackageJsonInstance;
 /**
  * Extended PackageJson type based on NPMCliPackageJson.Content with Socket-specific additions.
  * @extends NPMCliPackageJson.Content (from @npmcli/package-json)

package/dist/packages.js

@@ -31,7 +31,7 @@ __export(packages_exports, {
   fetchPackageProvenance: () => import_provenance.fetchPackageProvenance,
   findPackageExtensions: () => import_operations.findPackageExtensions,
   findTypesForSubpath: () => import_exports.findTypesForSubpath,
-  getEditablePackageJsonClass: () => import_editable.getEditablePackageJsonClass,
+  getEditablePackageJsonClass: () => import_edit.getEditablePackageJsonClass,
   getExportFilePaths: () => import_exports.getExportFilePaths,
   getProvenanceDetails: () => import_provenance.getProvenanceDetails,
   getReleaseTag: () => import_operations.getReleaseTag,
@@ -50,7 +50,7 @@ __export(packages_exports, {
   normalizePackageJson: () => import_normalize.normalizePackageJson,
   packPackage: () => import_operations.packPackage,
   parseSpdxExp: () => import_licenses.parseSpdxExp,
-  pkgJsonToEditable: () => import_editable.pkgJsonToEditable,
+  pkgJsonToEditable: () => import_edit.pkgJsonToEditable,
   readPackageJson: () => import_operations.readPackageJson,
   readPackageJsonSync: () => import_operations.readPackageJsonSync,
   resolveEscapedScope: () => import_normalize.resolveEscapedScope,
@@ -62,13 +62,13 @@ __export(packages_exports, {
   resolvePackageLicenses: () => import_licenses.resolvePackageLicenses,
   resolvePackageName: () => import_operations.resolvePackageName,
   resolveRegistryPackageName: () => import_operations.resolveRegistryPackageName,
-  toEditablePackageJson: () => import_editable.toEditablePackageJson,
-  toEditablePackageJsonSync: () => import_editable.toEditablePackageJsonSync,
+  toEditablePackageJson: () => import_edit.toEditablePackageJson,
+  toEditablePackageJsonSync: () => import_edit.toEditablePackageJsonSync,
   unescapeScope: () => import_normalize.unescapeScope,
   visitLicenses: () => import_licenses.visitLicenses
 });
 module.exports = __toCommonJS(packages_exports);
-var import_editable = require("./packages/editable");
+var import_edit = require("./packages/edit");
 var import_exports = require("./packages/exports");
 var import_isolation = require("./packages/isolation");
 var import_licenses = require("./packages/licenses");

package/dist/promises.d.ts

@@ -208,25 +208,6 @@ export declare function normalizeIterationOptions(options?: number | IterationOp
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function normalizeRetryOptions(options?: number | RetryOptions | undefined): RetryOptions;
-/**
- * Resolve retry options from various input formats.
- *
- * Converts shorthand and partial options into a base configuration that can be
- * further normalized. This is an internal helper for option processing.
- *
- * @param options - Retry count as number, or partial options object, or undefined
- * @returns Resolved retry options with defaults for basic properties
- *
- * @example
- * resolveRetryOptions(3)
- * // => { retries: 3, minTimeout: 200, maxTimeout: 10000, factor: 2 }
- *
- * @example
- * resolveRetryOptions({ retries: 5, maxTimeout: 5000 })
- * // => { retries: 5, minTimeout: 200, maxTimeout: 5000, factor: 2 }
- */
-/*@__NO_SIDE_EFFECTS__*/
-export declare function resolveRetryOptions(options?: number | RetryOptions | undefined): RetryOptions;
 /**
  * Execute an async function for each array element with concurrency control.
  *
@@ -455,3 +436,22 @@ export declare function pFilterChunk<T>(chunks: T[][], callbackFn: (value: T) =>
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function pRetry<T>(callbackFn: (...args: unknown[]) => Promise<T>, options?: number | RetryOptions | undefined): Promise<T | undefined>;
+/**
+ * Resolve retry options from various input formats.
+ *
+ * Converts shorthand and partial options into a base configuration that can be
+ * further normalized. This is an internal helper for option processing.
+ *
+ * @param options - Retry count as number, or partial options object, or undefined
+ * @returns Resolved retry options with defaults for basic properties
+ *
+ * @example
+ * resolveRetryOptions(3)
+ * // => { retries: 3, minTimeout: 200, maxTimeout: 10000, factor: 2 }
+ *
+ * @example
+ * resolveRetryOptions({ retries: 5, maxTimeout: 5000 })
+ * // => { retries: 5, minTimeout: 200, maxTimeout: 5000, factor: 2 }
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function resolveRetryOptions(options?: number | RetryOptions | undefined): RetryOptions;