@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/fs/read-file.d.ts

@@ -0,0 +1,150 @@
+/**
+ * @file File-content readers — UTF-8 / binary / safe variants (sync + async).
+ *   The `safe*` versions trap errors and return `undefined` (or a
+ *   caller-supplied `defaultValue`) so they fit the non-throwing-fallback shape
+ *   used elsewhere in the lib. The encoding `null` overload returns a `Buffer`;
+ *   the default and any string encoding return a string. The runtime fast-path
+ *   normalizes encoding once and forwards untouched options to `node:fs`.
+ */
+import type { PathLike } from 'node:fs';
+import type { ReadFileOptions, SafeReadOptions } from './types';
+/**
+ * Read a file as binary data asynchronously. Returns a Buffer without encoding
+ * the contents. Useful for reading images, archives, or other binary formats.
+ *
+ * @example
+ *   ;```ts
+ *   // Read an image file
+ *   const imageBuffer = await readFileBinary('./image.png')
+ *
+ *   // Read with abort signal
+ *   const buffer = await readFileBinary('./data.bin', { signal: abortSignal })
+ *   ```
+ *
+ * @param filepath - Path to file.
+ * @param options - Read options (encoding is forced to null for binary)
+ *
+ * @returns Promise resolving to Buffer containing file contents
+ */
+export declare function readFileBinary(filepath: PathLike, options?: ReadFileOptions | undefined): Promise<NonSharedBuffer>;
+/**
+ * Read a file as binary data synchronously. Returns a Buffer without encoding
+ * the contents. Useful for reading images, archives, or other binary formats.
+ *
+ * @example
+ *   ;```ts
+ *   // Read an image file
+ *   const imageBuffer = readFileBinarySync('./logo.png')
+ *
+ *   // Read a compressed file
+ *   const gzipData = readFileBinarySync('./archive.gz')
+ *   ```
+ *
+ * @param filepath - Path to file.
+ * @param options - Read options (encoding is forced to null for binary)
+ *
+ * @returns Buffer containing file contents
+ */
+export declare function readFileBinarySync(filepath: PathLike, options?: ReadFileOptions | undefined): string | NonSharedBuffer;
+/**
+ * Read a file as UTF-8 text asynchronously. Returns a string with the file
+ * contents decoded as UTF-8. This is the most common way to read text files.
+ *
+ * @example
+ *   ;```ts
+ *   // Read a text file
+ *   const content = await readFileUtf8('./README.md')
+ *
+ *   // Read with custom encoding
+ *   const content = await readFileUtf8('./data.txt', { encoding: 'utf-8' })
+ *   ```
+ *
+ * @param filepath - Path to file.
+ * @param options - Read options including encoding and abort signal.
+ *
+ * @returns Promise resolving to string containing file contents
+ */
+export declare function readFileUtf8(filepath: PathLike, options?: ReadFileOptions | undefined): Promise<string>;
+/**
+ * Read a file as UTF-8 text synchronously. Returns a string with the file
+ * contents decoded as UTF-8. This is the most common way to read text files
+ * synchronously.
+ *
+ * @example
+ *   ;```ts
+ *   // Read a configuration file
+ *   const config = readFileUtf8Sync('./config.txt')
+ *
+ *   // Read with custom options
+ *   const data = readFileUtf8Sync('./data.txt', { encoding: 'utf8' })
+ *   ```
+ *
+ * @param filepath - Path to file.
+ * @param options - Read options including encoding.
+ *
+ * @returns String containing file contents
+ */
+export declare function readFileUtf8Sync(filepath: PathLike, options?: ReadFileOptions | undefined): string | NonSharedBuffer;
+/**
+ * Safely read a file asynchronously, returning undefined on error. Useful when
+ * you want to attempt reading a file without handling errors explicitly.
+ * Returns undefined for any error (file not found, permission denied, etc.).
+ * Defaults to UTF-8 encoding, returning a string unless encoding is explicitly
+ * set to null.
+ *
+ * @example
+ *   ;```ts
+ *   // Try to read a file as UTF-8 string (default), get undefined if it doesn't exist
+ *   const content = await safeReadFile('./optional-config.txt')
+ *   if (content) {
+ *     console.log('Config found:', content)
+ *   }
+ *
+ *   // Read with specific encoding
+ *   const data = await safeReadFile('./data.txt', { encoding: 'utf8' })
+ *
+ *   // Read as Buffer by setting encoding to null
+ *   const buffer = await safeReadFile('./binary.dat', { encoding: null })
+ *   ```
+ *
+ * @param filepath - Path to file.
+ * @param options - Read options including encoding and default value.
+ *
+ * @returns Promise resolving to file contents (string by default), or undefined
+ *   on error.
+ */
+export declare function safeReadFile(filepath: PathLike, options: SafeReadOptions & {
+    encoding: null;
+}): Promise<Buffer | undefined>;
+export declare function safeReadFile(filepath: PathLike, options?: SafeReadOptions | undefined): Promise<string | undefined>;
+/**
+ * Safely read a file synchronously, returning undefined on error. Useful when
+ * you want to attempt reading a file without handling errors explicitly.
+ * Returns undefined for any error (file not found, permission denied, etc.).
+ * Defaults to UTF-8 encoding, returning a string unless encoding is explicitly
+ * set to null.
+ *
+ * @example
+ *   ;```ts
+ *   // Try to read a config file as UTF-8 string (default)
+ *   const config = safeReadFileSync('./config.txt')
+ *   if (config) {
+ *     console.log('Config loaded successfully')
+ *   }
+ *
+ *   // Read with explicit encoding
+ *   const data = safeReadFileSync('./data.txt', { encoding: 'utf8' })
+ *
+ *   // Read binary file by setting encoding to null
+ *   const buffer = safeReadFileSync('./image.png', { encoding: null })
+ *   ```
+ *
+ * @param filepath - Path to file.
+ * @param options - Read options including encoding and default value.
+ *
+ * @returns File contents (string by default), or undefined on error
+ */
+export declare function safeReadFileSync(filepath: PathLike, options: SafeReadOptions & {
+    encoding: null;
+}): Buffer | undefined;
+export declare function safeReadFileSync(filepath: PathLike, options?: SafeReadOptions | undefined): string | undefined;

package/dist/fs/read-file.js

@@ -0,0 +1,131 @@
+"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 read_file_exports = {};
+__export(read_file_exports, {
+  readFileBinary: () => readFileBinary,
+  readFileBinarySync: () => readFileBinarySync,
+  readFileUtf8: () => readFileUtf8,
+  readFileUtf8Sync: () => readFileUtf8Sync,
+  safeReadFile: () => safeReadFile,
+  safeReadFileSync: () => safeReadFileSync
+});
+module.exports = __toCommonJS(read_file_exports);
+var import_abort = require("../process/abort");
+var import_fs = require("../node/fs");
+var import_buffer = require("../primordials/buffer");
+var import_encoding = require("./encoding");
+const abortSignal = (0, import_abort.getAbortSignal)();
+// @__NO_SIDE_EFFECTS__
+async function readFileBinary(filepath, options) {
+  const opts = typeof options === "string" ? { encoding: options } : options;
+  const fs = (0, import_fs.getNodeFs)();
+  return await fs.promises.readFile(filepath, {
+    signal: abortSignal,
+    ...opts,
+    encoding: void 0
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function readFileBinarySync(filepath, options) {
+  const opts = typeof options === "string" ? { encoding: options } : options;
+  const fs = (0, import_fs.getNodeFs)();
+  return fs.readFileSync(filepath, {
+    ...opts,
+    encoding: void 0
+  });
+}
+// @__NO_SIDE_EFFECTS__
+async function readFileUtf8(filepath, options) {
+  const opts = typeof options === "string" ? { encoding: options } : options;
+  const fs = (0, import_fs.getNodeFs)();
+  return await fs.promises.readFile(filepath, {
+    signal: abortSignal,
+    ...opts,
+    encoding: "utf8"
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function readFileUtf8Sync(filepath, options) {
+  const opts = typeof options === "string" ? { encoding: options } : options;
+  const fs = (0, import_fs.getNodeFs)();
+  return fs.readFileSync(filepath, {
+    ...opts,
+    encoding: "utf8"
+  });
+}
+// @__NO_SIDE_EFFECTS__
+async function safeReadFile(filepath, options) {
+  const opts = typeof options === "string" ? { __proto__: null, encoding: options } : { __proto__: null, ...options };
+  const { defaultValue, ...rawReadOpts } = opts;
+  const readOpts = { __proto__: null, ...rawReadOpts };
+  const shouldReturnBuffer = readOpts.encoding === null;
+  const encoding = shouldReturnBuffer ? void 0 : (0, import_encoding.normalizeEncoding)(readOpts.encoding);
+  const fs = (0, import_fs.getNodeFs)();
+  try {
+    return await fs.promises.readFile(filepath, {
+      __proto__: null,
+      signal: abortSignal,
+      ...readOpts,
+      encoding
+    });
+  } catch {
+  }
+  if (defaultValue === void 0) {
+    return void 0;
+  }
+  if (shouldReturnBuffer) {
+    return (0, import_buffer.BufferIsBuffer)(defaultValue) ? defaultValue : void 0;
+  }
+  return typeof defaultValue === "string" ? defaultValue : String(defaultValue);
+}
+// @__NO_SIDE_EFFECTS__
+function safeReadFileSync(filepath, options) {
+  const opts = typeof options === "string" ? { __proto__: null, encoding: options } : { __proto__: null, ...options };
+  const { defaultValue, ...rawReadOpts } = opts;
+  const readOpts = { __proto__: null, ...rawReadOpts };
+  const shouldReturnBuffer = readOpts.encoding === null;
+  const encoding = shouldReturnBuffer ? void 0 : (0, import_encoding.normalizeEncoding)(readOpts.encoding);
+  const fs = (0, import_fs.getNodeFs)();
+  try {
+    return fs.readFileSync(filepath, {
+      __proto__: null,
+      ...readOpts,
+      encoding
+    });
+  } catch {
+  }
+  if (defaultValue === void 0) {
+    return void 0;
+  }
+  if (shouldReturnBuffer) {
+    return (0, import_buffer.BufferIsBuffer)(defaultValue) ? defaultValue : void 0;
+  }
+  return typeof defaultValue === "string" ? defaultValue : String(defaultValue);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readFileBinary,
+  readFileBinarySync,
+  readFileUtf8,
+  readFileUtf8Sync,
+  safeReadFile,
+  safeReadFileSync
+});

package/dist/fs/read-json-cache.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @file Process-scoped LRU cache for `readJson` / `readJsonSync` results, keyed
+ *   by absolute path + stat (`ino + size + mtimeMs`). Why default-on caching is
+ *   safe:
+ *
+ *   - Stat-validated keys: a `stat()` call before serving a cache hit ensures the
+ *     file hasn't changed (mtime + size mismatch ⇒ cache miss, re-read).
+ *   - Defensive clone on hit: every hit returns `structuredClone(parsed)` so
+ *     callers can mutate the returned object without poisoning the cache for
+ *     the next reader. The clone cost is far less than re-read + re-parse for
+ *     anything bigger than a trivial JSON document.
+ *   - Reviver opt-out: when the caller passes a `reviver` function, we skip the
+ *     cache. Function identity isn't safely hashable across boundaries, and the
+ *     reviver can produce a different shape from the same bytes.
+ *   - Per-call escape hatch: `cache: false` in the options bypasses the cache for
+ *     cases where staleness must be observed (file-watcher tooling, etc.).
+ *   - Bounded growth: an LRU cap (default 256 entries) protects long-running
+ *     daemons. Tunable via `SOCKET_LIB_READ_JSON_CACHE_MAX` env or
+ *     `setReadJsonCacheMax()`.
+ *   - Test escape hatch: `clearReadJsonCache()` resets the whole cache between
+ *     test cases that rely on fresh reads. Not cached:
+ *   - Read failures (ENOENT under `throws: false` returns `undefined`). Caching
+ *     undefined would silently miss a file that gets created later.
+ *   - Reads with a `reviver` (see above).
+ *   - Reads with explicit `cache: false`.
+ *   - Relative paths whose `resolvePath` would change CWD-sensitively. We key on
+ *     the literal input path, so callers passing relative paths from different
+ *     CWDs would get separate cache entries — correct but pessimistic.
+ */
+import type { JsonValue } from '../json/types';
+/**
+ * Drop all cached entries. Tests call this between cases that depend on a fresh
+ * read; long-running daemons can call it on file-watcher invalidation events
+ * for paths the daemon knows are about to change in bulk.
+ */
+export declare function clearReadJsonCache(): void;
+/**
+ * Look up a cached parse result. Returns a fresh structured clone on hit (so
+ * callers can mutate freely), or `undefined` on miss.
+ *
+ * @param key Cache key — absolute file path. Caller resolves any relative
+ *   inputs to absolute so two different CWDs don't share an entry.
+ * @param ino Inode (or `0` on platforms without one — Windows reports 0 from
+ *   the Node `fs.Stats` shim, in which case size + mtimeMs carry the
+ *   invalidation signal).
+ * @param size File size in bytes.
+ * @param mtimeMs Modification time in milliseconds.
+ */
+export declare function getCachedJson(key: string, ino: number, size: number, mtimeMs: number): JsonValue | undefined;
+/**
+ * Snapshot diagnostics. Useful for tests and for tooling that wants to log
+ * cache effectiveness at end of run.
+ */
+export declare function getReadJsonCacheStats(): {
+    size: number;
+    max: number;
+    ttlMs: number;
+    hits: number;
+    misses: number;
+};
+export declare function readMaxFromEnv(): number;
+export declare function readTtlFromEnv(): number;
+/**
+ * Store a parsed value. Evicts the oldest entry when the cache is full.
+ *
+ * Never stores `undefined` — callers must guard for the "file not found,
+ * throws: false" case before invoking this.
+ */
+export declare function setCachedJson(key: string, ino: number, size: number, mtimeMs: number, parsed: JsonValue): void;
+/**
+ * Adjust the cache size cap at runtime. Useful for tooling that knows it'll
+ * walk many manifests in one pass and wants a larger cap, or for tests that
+ * want to bound the cap small so eviction is observable.
+ *
+ * Trims excess entries on shrink.
+ */
+export declare function setReadJsonCacheMax(max: number): void;
+/**
+ * Adjust the time-based ejection window at runtime. Default is 5 minutes; pass
+ * `0` to disable time-based ejection entirely (entries then live until LRU
+ * eviction or `clearReadJsonCache`).
+ */
+export declare function setReadJsonCacheTtlMs(ttlMs: number): void;

package/dist/fs/read-json-cache.js

@@ -0,0 +1,156 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var read_json_cache_exports = {};
+__export(read_json_cache_exports, {
+  clearReadJsonCache: () => clearReadJsonCache,
+  getCachedJson: () => getCachedJson,
+  getReadJsonCacheStats: () => getReadJsonCacheStats,
+  readMaxFromEnv: () => readMaxFromEnv,
+  readTtlFromEnv: () => readTtlFromEnv,
+  setCachedJson: () => setCachedJson,
+  setReadJsonCacheMax: () => setReadJsonCacheMax,
+  setReadJsonCacheTtlMs: () => setReadJsonCacheTtlMs
+});
+module.exports = __toCommonJS(read_json_cache_exports);
+var import_node_process = __toESM(require("node:process"));
+var import_date = require("../primordials/date");
+var import_error = require("../primordials/error");
+var import_map_set = require("../primordials/map-set");
+var import_number = require("../primordials/number");
+const DEFAULT_MAX_ENTRIES = 256;
+const DEFAULT_TTL_MS = 5 * 60 * 1e3;
+const cache = new import_map_set.MapCtor();
+let cacheMax = readMaxFromEnv();
+let cacheTtlMs = readTtlFromEnv();
+let hits = 0;
+let misses = 0;
+function clearReadJsonCache() {
+  cache.clear();
+  hits = 0;
+  misses = 0;
+}
+function getCachedJson(key, ino, size, mtimeMs) {
+  const entry = cache.get(key);
+  if (!entry) {
+    misses += 1;
+    return void 0;
+  }
+  if (cacheTtlMs > 0 && (0, import_date.DateNow)() - entry.insertedAt > cacheTtlMs) {
+    cache.delete(key);
+    misses += 1;
+    return void 0;
+  }
+  if (entry.ino !== ino || entry.size !== size || entry.mtimeMs !== mtimeMs) {
+    cache.delete(key);
+    misses += 1;
+    return void 0;
+  }
+  hits += 1;
+  return structuredClone(entry.parsed);
+}
+function getReadJsonCacheStats() {
+  return {
+    size: cache.size,
+    max: cacheMax,
+    ttlMs: cacheTtlMs,
+    hits,
+    misses
+  };
+}
+function readMaxFromEnv() {
+  const env = import_node_process.default.env["SOCKET_LIB_READ_JSON_CACHE_MAX"];
+  if (env) {
+    const n = (0, import_number.NumberParseInt)(env, 10);
+    if (n > 0 && (0, import_number.NumberIsFinite)(n)) {
+      return n;
+    }
+  }
+  return DEFAULT_MAX_ENTRIES;
+}
+function readTtlFromEnv() {
+  const env = import_node_process.default.env["SOCKET_LIB_READ_JSON_CACHE_TTL_MS"];
+  if (env) {
+    const n = (0, import_number.NumberParseInt)(env, 10);
+    if (n >= 0 && (0, import_number.NumberIsFinite)(n)) {
+      return n;
+    }
+  }
+  return DEFAULT_TTL_MS;
+}
+function setCachedJson(key, ino, size, mtimeMs, parsed) {
+  if (cache.size >= cacheMax) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) {
+      cache.delete(oldest);
+    }
+  }
+  cache.set(key, {
+    ino,
+    size,
+    mtimeMs,
+    parsed: structuredClone(parsed),
+    insertedAt: (0, import_date.DateNow)()
+  });
+}
+function setReadJsonCacheMax(max) {
+  if (max <= 0 || !(0, import_number.NumberIsFinite)(max)) {
+    throw new import_error.ErrorCtor(
+      `setReadJsonCacheMax: max must be a positive finite number, got ${max}`
+    );
+  }
+  cacheMax = max;
+  while (cache.size > cacheMax) {
+    const oldest = cache.keys().next().value;
+    if (oldest === void 0) {
+      break;
+    }
+    cache.delete(oldest);
+  }
+}
+function setReadJsonCacheTtlMs(ttlMs) {
+  if (ttlMs < 0 || !(0, import_number.NumberIsFinite)(ttlMs)) {
+    throw new import_error.ErrorCtor(
+      `setReadJsonCacheTtlMs: ttlMs must be a non-negative finite number, got ${ttlMs}`
+    );
+  }
+  cacheTtlMs = ttlMs;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearReadJsonCache,
+  getCachedJson,
+  getReadJsonCacheStats,
+  readMaxFromEnv,
+  readTtlFromEnv,
+  setCachedJson,
+  setReadJsonCacheMax,
+  setReadJsonCacheTtlMs
+});

package/dist/fs/read-json.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @file Read-and-parse helpers for JSON files. Wraps fs reads in actionable
+ *   error messages keyed off `ENOENT` / `EACCES` / `EPERM` so callers see "JSON
+ *   file not found" / "Permission denied" rather than the bare errno. Both
+ *   variants honor `throws: false` to fall back to `undefined` on parse or read
+ *   failure. Both variants cache parse results by default — keyed on `path +
+ *   ino + size \+ mtimeMs`, with a defensive `structuredClone` on every hit so
+ *   callers can mutate the returned object freely. See `_read-json-cache.ts`
+ *   for the safety rationale + opt-out controls.
+ */
+import { clearReadJsonCache, getReadJsonCacheStats, setReadJsonCacheMax, setReadJsonCacheTtlMs } from './read-json-cache';
+export { clearReadJsonCache, getReadJsonCacheStats, setReadJsonCacheMax, setReadJsonCacheTtlMs, };
+import type { PathLike } from 'node:fs';
+import type { ReadJsonOptions } from './types';
+/**
+ * Read and parse a JSON file asynchronously. Reads the file as UTF-8 text and
+ * parses it as JSON. Optionally accepts a reviver function to transform parsed
+ * values.
+ *
+ * @example
+ *   ;```ts
+ *   // Read and parse package.json
+ *   const pkg = await readJson('./package.json')
+ *
+ *   // Read JSON with custom reviver
+ *   const data = await readJson('./data.json', {
+ *     reviver: (key, value) => {
+ *       if (key === 'date') return new Date(value)
+ *       return value
+ *     },
+ *   })
+ *
+ *   // Don't throw on parse errors
+ *   const config = await readJson('./config.json', { throws: false })
+ *   if (config === undefined) {
+ *     console.log('Failed to parse config')
+ *   }
+ *   ```
+ *
+ * @param filepath - Path to JSON file.
+ * @param options - Read and parse options.
+ *
+ * @returns Promise resolving to parsed JSON value, or undefined if throws is
+ *   false and an error occurs.
+ */
+export declare function readJson(filepath: PathLike, options?: ReadJsonOptions | string | undefined): Promise<import("../json/types").JsonValue | undefined>;
+/**
+ * Read and parse a JSON file synchronously. Reads the file as UTF-8 text and
+ * parses it as JSON. Optionally accepts a reviver function to transform parsed
+ * values.
+ *
+ * @example
+ *   ;```ts
+ *   // Read and parse tsconfig.json
+ *   const tsconfig = readJsonSync('./tsconfig.json')
+ *
+ *   // Read JSON with custom reviver
+ *   const data = readJsonSync('./data.json', {
+ *     reviver: (key, value) => {
+ *       if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}/.test(value)) {
+ *         return new Date(value)
+ *       }
+ *       return value
+ *     },
+ *   })
+ *
+ *   // Don't throw on parse errors
+ *   const config = readJsonSync('./config.json', { throws: false })
+ *   ```
+ *
+ * @param filepath - Path to JSON file.
+ * @param options - Read and parse options.
+ *
+ * @returns Parsed JSON value, or undefined if throws is false and an error
+ *   occurs.
+ */
+export declare function readJsonSync(filepath: PathLike, options?: ReadJsonOptions | string | undefined): import("../json/types").JsonValue | undefined;