@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/json/format.js

@@ -1,124 +1,223 @@
 "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 format_exports = {};
-__export(format_exports, {
-  INDENT_SYMBOL: () => INDENT_SYMBOL,
-  NEWLINE_SYMBOL: () => NEWLINE_SYMBOL,
-  detectIndent: () => detectIndent,
-  detectNewline: () => detectNewline,
-  extractFormatting: () => extractFormatting,
-  getDefaultFormatting: () => getDefaultFormatting,
-  getFormattingFromContent: () => getFormattingFromContent,
-  shouldSave: () => shouldSave,
-  sortKeys: () => sortKeys,
-  stringifyWithFormatting: () => stringifyWithFormatting,
-  stripFormattingSymbols: () => stripFormattingSymbols
-});
-module.exports = __toCommonJS(format_exports);
-var import_json = require("../primordials/json");
-var import_object = require("../primordials/object");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_object = require('../primordials/object.js');
+const require_primordials_json = require('../primordials/json.js');
+
+//#region src/json/format.ts
+/**
+* @file Shared utilities for JSON formatting preservation and manipulation.
+*   Provides functions for detecting and preserving indentation, line endings,
+*   and determining when JSON files should be saved based on content changes.
+*/
+/**
+* Symbols used to store formatting metadata in JSON objects.
+*/
 const INDENT_SYMBOL = Symbol.for("indent");
 const NEWLINE_SYMBOL = Symbol.for("newline");
+/**
+* Detect indentation from a JSON string. Supports space-based indentation
+* (returns count) or mixed indentation (returns string).
+*
+* @example
+*   ;```ts
+*   detectIndent('{\n  "key": "value"\n}') // => 2
+*   detectIndent('{\n    "key": "value"\n}') // => 4
+*   detectIndent('{\n\t"key": "value"\n}') // => '\t'
+*   ```
+*
+* @param json - JSON string to analyze.
+*
+* @returns Number of spaces or indentation string, defaults to 2 if not
+*   detected.
+*/
 function detectIndent(json) {
-  const match = json.match(/^[{[][\r\n]+(\s+)/m);
-  if (!match) {
-    return 2;
-  }
-  const indent = match[1];
-  if (/^ +$/.test(indent)) {
-    return indent.length;
-  }
-  return indent;
+	const match = json.match(/^[{[][\r\n]+(\s+)/m);
+	if (!match) return 2;
+	const indent = match[1];
+	if (/^ +$/.test(indent)) return indent.length;
+	return indent;
 }
+/**
+* Detect newline character(s) from a JSON string. Supports LF (\n) and CRLF
+* (\r\n) line endings.
+*
+* @example
+*   ;```ts
+*   detectNewline('{\n  "key": "value"\n}') // => '\n'
+*   detectNewline('{\r\n  "key": "value"\r\n}') // => '\r\n'
+*   ```
+*
+* @param json - JSON string to analyze.
+*
+* @returns Line ending string ('\n' or '\r\n'), defaults to '\n' if not
+*   detected.
+*/
 function detectNewline(json) {
-  const match = json.match(/\r?\n/);
-  return match ? match[0] : "\n";
+	const match = json.match(/\r?\n/);
+	return match ? match[0] : "\n";
 }
+/**
+* Extract formatting metadata from a JSON string.
+*
+* @example
+*   ;```ts
+*   const formatting = extractFormatting('{\n  "key": "value"\n}')
+*   // => { indent: 2, newline: '\n' }
+*   ```
+*
+* @param json - JSON string to analyze.
+*
+* @returns Object containing indent and newline formatting
+*/
 function extractFormatting(json) {
-  return {
-    indent: detectIndent(json),
-    newline: detectNewline(json)
-  };
+	return {
+		indent: detectIndent(json),
+		newline: detectNewline(json)
+	};
 }
+/**
+* Get default formatting for JSON files.
+*
+* @example
+*   ;```typescript
+*   const fmt = getDefaultFormatting()
+*   // { indent: 2, newline: '\n' }
+*   ```
+*
+* @returns Default formatting (2 spaces, LF line endings)
+*/
 function getDefaultFormatting() {
-  return {
-    indent: 2,
-    newline: "\n"
-  };
+	return {
+		indent: 2,
+		newline: "\n"
+	};
 }
+/**
+* Extract formatting from content object that has symbol-based metadata.
+*
+* @example
+*   ;```typescript
+*   const content = {
+*     [Symbol.for('indent')]: 4,
+*     [Symbol.for('newline')]: '\r\n',
+*   }
+*   getFormattingFromContent(content) // { indent: 4, newline: "\r\n" }
+*   ```
+*
+* @param content - Content object with Symbol.for('indent') and
+*   Symbol.for('newline')
+*
+* @returns Formatting metadata, or defaults if symbols not present
+*/
 function getFormattingFromContent(content) {
-  const indent = content[INDENT_SYMBOL];
-  const newline = content[NEWLINE_SYMBOL];
-  return {
-    indent: indent === void 0 || indent === null ? 2 : indent,
-    newline: newline === void 0 || newline === null ? "\n" : newline
-  };
+	const indent = content[INDENT_SYMBOL];
+	const newline = content[NEWLINE_SYMBOL];
+	return {
+		indent: indent === void 0 || indent === null ? 2 : indent,
+		newline: newline === void 0 || newline === null ? "\n" : newline
+	};
 }
+/**
+* Determine if content should be saved based on changes and options. Compares
+* current content with original content and respects options like
+* ignoreWhitespace and sort.
+*
+* @example
+*   ;```ts
+*   const current = { key: 'new-value', [Symbol.for('indent')]: 2 }
+*   const original = { key: 'old-value', [Symbol.for('indent')]: 2 }
+*   shouldSave(current, original, '{\n  "key": "old-value"\n}\n')
+*   // => true
+*   ```
+*
+* @param currentContent - Current content object (may include formatting
+*   symbols)
+* @param originalContent - Original content for comparison (may include
+*   formatting symbols)
+* @param originalFileContent - Original file content as string (for whitespace
+*   comparison)
+* @param options - Options controlling save behavior.
+*
+* @returns True if content should be saved, false otherwise
+*/
 function shouldSave(currentContent, originalContent, originalFileContent, options = {}) {
-  const { ignoreWhitespace = false, sort = false, sortFn } = options;
-  const content = stripFormattingSymbols(currentContent);
-  const sortedContent = sortFn ? sortFn(content) : sort ? sortKeys(content) : content;
-  const origContent = originalContent ? stripFormattingSymbols(originalContent) : {};
-  if (ignoreWhitespace) {
-    const util = require("node:util");
-    return !util.isDeepStrictEqual(sortedContent, origContent);
-  }
-  const formatting = getFormattingFromContent(currentContent);
-  const newFileContent = stringifyWithFormatting(sortedContent, formatting);
-  return newFileContent.trim() !== originalFileContent.trim();
+	const { ignoreWhitespace = false, sort = false, sortFn } = options;
+	const content = stripFormattingSymbols(currentContent);
+	const sortedContent = sortFn ? sortFn(content) : sort ? sortKeys(content) : content;
+	const origContent = originalContent ? stripFormattingSymbols(originalContent) : {};
+	if (ignoreWhitespace) return !require("node:util").isDeepStrictEqual(sortedContent, origContent);
+	return stringifyWithFormatting(sortedContent, getFormattingFromContent(currentContent)).trim() !== originalFileContent.trim();
 }
+/**
+* Sort object keys alphabetically. Creates a new object with sorted keys (does
+* not mutate input).
+*
+* @example
+*   ;```ts
+*   sortKeys({ z: 3, a: 1, m: 2 })
+*   // => { a: 1, m: 2, z: 3 }
+*   ```
+*
+* @param obj - Object to sort.
+*
+* @returns New object with alphabetically sorted keys
+*/
 function sortKeys(obj) {
-  const sorted = { __proto__: null };
-  const keys = (0, import_object.ObjectKeys)(obj).sort();
-  for (const key of keys) {
-    sorted[key] = obj[key];
-  }
-  return sorted;
+	const sorted = { __proto__: null };
+	const keys = require_primordials_object.ObjectKeys(obj).sort();
+	for (const key of keys) sorted[key] = obj[key];
+	return sorted;
 }
+/**
+* Stringify JSON with specific formatting. Applies indentation and line ending
+* preferences.
+*
+* @example
+*   ;```ts
+*   stringifyWithFormatting({ key: 'value' }, { indent: 4, newline: '\r\n' })
+*   // => '{\r\n    "key": "value"\r\n}\r\n'
+*   ```
+*
+* @param content - Object to stringify.
+* @param formatting - Formatting preferences (indent and newline)
+*
+* @returns Formatted JSON string with trailing newline
+*/
 function stringifyWithFormatting(content, formatting) {
-  const { indent, newline } = formatting;
-  const format = indent === void 0 || indent === null ? "  " : indent;
-  const eol = newline === void 0 || newline === null ? "\n" : newline;
-  return `${(0, import_json.JSONStringify)(content, void 0, format)}
-`.replace(/\n/g, eol);
+	const { indent, newline } = formatting;
+	const format = indent === void 0 || indent === null ? "  " : indent;
+	const eol = newline === void 0 || newline === null ? "\n" : newline;
+	return `${require_primordials_json.JSONStringify(content, void 0, format)}\n`.replace(/\n/g, eol);
 }
+/**
+* Strip formatting symbols from content object. Removes Symbol.for('indent')
+* and Symbol.for('newline') from the object.
+*
+* @example
+*   ;```typescript
+*   const obj = { key: 'value', [Symbol.for('indent')]: 2 }
+*   stripFormattingSymbols(obj) // { key: "value" }
+*   ```
+*
+* @param content - Content object with potential symbol properties.
+*
+* @returns Object with symbols removed
+*/
 function stripFormattingSymbols(content) {
-  const {
-    [INDENT_SYMBOL]: _indent,
-    [NEWLINE_SYMBOL]: _newline,
-    ...rest
-  } = content;
-  return rest;
+	const { [INDENT_SYMBOL]: _indent, [NEWLINE_SYMBOL]: _newline, ...rest } = content;
+	return rest;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  INDENT_SYMBOL,
-  NEWLINE_SYMBOL,
-  detectIndent,
-  detectNewline,
-  extractFormatting,
-  getDefaultFormatting,
-  getFormattingFromContent,
-  shouldSave,
-  sortKeys,
-  stringifyWithFormatting,
-  stripFormattingSymbols
-});
+
+//#endregion
+exports.INDENT_SYMBOL = INDENT_SYMBOL;
+exports.NEWLINE_SYMBOL = NEWLINE_SYMBOL;
+exports.detectIndent = detectIndent;
+exports.detectNewline = detectNewline;
+exports.extractFormatting = extractFormatting;
+exports.getDefaultFormatting = getDefaultFormatting;
+exports.getFormattingFromContent = getFormattingFromContent;
+exports.shouldSave = shouldSave;
+exports.sortKeys = sortKeys;
+exports.stringifyWithFormatting = stringifyWithFormatting;
+exports.stripFormattingSymbols = stripFormattingSymbols;

package/dist/json/parse.js

@@ -1,121 +1,218 @@
 "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 parse_exports = {};
-__export(parse_exports, {
-  isBuffer: () => isBuffer,
-  isJsonPrimitive: () => isJsonPrimitive,
-  parseJson: () => parseJson,
-  parseJsonSafe: () => parseJsonSafe,
-  prototypePollutionReviver: () => prototypePollutionReviver
-});
-module.exports = __toCommonJS(parse_exports);
-var import_validate = require("../schema/validate");
-var import_transform = require("../strings/transform");
-var import_buffer = require("../primordials/buffer");
-var import_error = require("../primordials/error");
-var import_json = require("../primordials/json");
-var import_map_set = require("../primordials/map-set");
-// @__NO_SIDE_EFFECTS__
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_buffer = require('../primordials/buffer.js');
+const require_primordials_error = require('../primordials/error.js');
+const require_primordials_map_set = require('../primordials/map-set.js');
+const require_schema_validate = require('../schema/validate.js');
+const require_strings_transform = require('../strings/transform.js');
+const require_primordials_json = require('../primordials/json.js');
+
+//#region src/json/parse.ts
+/**
+* @file JSON parsing utilities with Buffer detection and BOM stripping.
+*   Provides safe JSON parsing with automatic encoding handling, plus
+*   `parseJsonSafe` for untrusted input (prototype-pollution protection + size
+*   limits + optional schema validation).
+*/
+/**
+* Check if a value is a Buffer instance. Uses duck-typing to detect Buffer
+* without requiring Node.js Buffer in type system.
+*
+* @example
+*   ;```ts
+*   isBuffer(Buffer.from('hello')) // => true
+*   isBuffer('hello') // => false
+*   isBuffer({ length: 5 }) // => false
+*   ```
+*
+* @param x - Value to check.
+*
+* @returns `true` if value is a Buffer, `false` otherwise
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function isBuffer(x) {
-  if (!x || typeof x !== "object") {
-    return false;
-  }
-  const obj = x;
-  if (typeof obj["length"] !== "number") {
-    return false;
-  }
-  if (typeof obj["copy"] !== "function" || typeof obj["slice"] !== "function") {
-    return false;
-  }
-  if (typeof obj["length"] === "number" && obj["length"] > 0 && typeof obj[0] !== "number") {
-    return false;
-  }
-  const Ctor = x.constructor;
-  return !!(typeof Ctor?.isBuffer === "function" && Ctor.isBuffer(x));
+	if (!x || typeof x !== "object") return false;
+	const obj = x;
+	if (typeof obj["length"] !== "number") return false;
+	if (typeof obj["copy"] !== "function" || typeof obj["slice"] !== "function") return false;
+	if (typeof obj["length"] === "number" && obj["length"] > 0 && typeof obj[0] !== "number") return false;
+	const Ctor = x.constructor;
+	return !!(typeof Ctor?.isBuffer === "function" && Ctor.isBuffer(x));
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Check if a value is a JSON primitive type. JSON primitives are: `null`,
+* `boolean`, `number`, or `string`.
+*
+* @example
+*   ;```ts
+*   isJsonPrimitive(null) // => true
+*   isJsonPrimitive(true) // => true
+*   isJsonPrimitive(42) // => true
+*   isJsonPrimitive('hello') // => true
+*   isJsonPrimitive({}) // => false
+*   isJsonPrimitive([]) // => false
+*   isJsonPrimitive(undefined) // => false
+*   ```
+*
+* @param value - Value to check.
+*
+* @returns `true` if value is a JSON primitive, `false` otherwise
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function isJsonPrimitive(value) {
-  return value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string";
+	return value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string";
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Parse JSON content with automatic Buffer handling and BOM stripping. Provides
+* safer JSON parsing with helpful error messages and optional error
+* suppression.
+*
+* Features: - Automatic UTF-8 Buffer conversion - BOM (Byte Order Mark)
+* stripping for cross-platform compatibility - Enhanced error messages with
+* filepath context - Optional error suppression (returns `undefined` instead of
+* throwing) - Optional reviver for transforming parsed values.
+*
+* @example
+*   ;```ts
+*   // Basic usage
+*   const data = parseJson('{"name":"example"}')
+*   console.log(data.name) // => 'example'
+*
+*   // Parse Buffer with UTF-8 BOM
+*   const buffer = Buffer.from('\uFEFF{"value":42}')
+*   const data = parseJson(buffer)
+*   console.log(data.value) // => 42
+*
+*   // Enhanced error messages with filepath
+*   try {
+*     parseJson('invalid', { filepath: 'config.json' })
+*   } catch (e) {
+*     console.error(e.message)
+*     // => "config.json: Unexpected token i in JSON at position 0"
+*   }
+*
+*   // Suppress errors
+*   const result = parseJson('invalid', { throws: false })
+*   console.log(result) // => undefined
+*
+*   // Transform values with reviver
+*   const json = '{"created":"2024-01-15T10:30:00Z"}'
+*   const data = parseJson(json, {
+*     reviver: (key, value) => {
+*       if (key === 'created' && typeof value === 'string') {
+*         return new Date(value)
+*       }
+*       return value
+*     },
+*   })
+*   console.log(data.created instanceof Date) // => true
+*   ```
+*
+* @param content - JSON string or Buffer to parse.
+* @param options - Optional parsing configuration.
+*
+* @returns Parsed JSON value, or `undefined` if parsing fails and `throws` is
+*   `false`
+*
+* @throws {SyntaxError} When JSON is invalid and `throws` is `true` (default)
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function parseJson(content, options) {
-  const { filepath, reviver, throws } = {
-    __proto__: null,
-    ...options
-  };
-  const shouldThrow = throws === void 0 || !!throws;
-  const jsonStr = /* @__PURE__ */ isBuffer(content) ? content.toString("utf8") : content;
-  try {
-    return (0, import_json.JSONParse)((0, import_transform.stripBom)(jsonStr), reviver);
-  } catch (e) {
-    if (shouldThrow) {
-      const error = e;
-      if (error && typeof filepath === "string") {
-        error.message = `${filepath}: ${error.message}`;
-      }
-      throw error;
-    }
-  }
-  return void 0;
+	const { filepath, reviver, throws } = {
+		__proto__: null,
+		...options
+	};
+	const shouldThrow = throws === void 0 || !!throws;
+	const jsonStr = /* @__PURE__ */ isBuffer(content) ? content.toString("utf8") : content;
+	try {
+		return require_primordials_json.JSONParse(/* @__PURE__ */ require_strings_transform.stripBom(jsonStr), reviver);
+	} catch (e) {
+		if (shouldThrow) {
+			const error = e;
+			if (error && typeof filepath === "string") error.message = `${filepath}: ${error.message}`;
+			throw error;
+		}
+	}
 }
-const DANGEROUS_KEYS = new import_map_set.SetCtor(["__proto__", "constructor", "prototype"]);
+const DANGEROUS_KEYS = new require_primordials_map_set.SetCtor([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
 const DEFAULT_MAX_SIZE = 10 * 1024 * 1024;
-// @__NO_SIDE_EFFECTS__
+/**
+* Safely parse JSON with optional schema validation and security controls.
+* Throws on parse failure, validation failure, or security violation.
+*
+* Recommended for parsing untrusted JSON (user input, network payloads,
+* anything beyond a trust boundary). Layers:
+*
+* 1. Size cap (default 10 MB) prevents memory exhaustion.
+* 2. Prototype-pollution reviver rejects `__proto__` / `constructor` / `prototype`
+*    keys at any depth (unless `allowPrototype: true`).
+* 3. Optional Zod-shaped schema validation via
+*    `@socketsecurity/lib/schema/validate`.
+*
+* For trusted-source reads (package.json, local config files), prefer
+* `parseJson()` — it offers Buffer/BOM handling and filepath-aware error
+* messages, without the untrusted-input overhead.
+*
+* @example
+*   ;```ts
+*   // Basic parsing with type inference.
+*   const data = parseJsonSafe<User>('{"name":"Alice","age":30}')
+*
+*   // With schema validation.
+*   import { z } from 'zod'
+*   const userSchema = z.object({ name: z.string(), age: z.number() })
+*   const user = parseJsonSafe('{"name":"Alice","age":30}', userSchema)
+*
+*   // With size limit.
+*   const data = parseJsonSafe(jsonString, undefined, { maxSize: 1024 })
+*
+*   // Allow prototype keys (DANGEROUS — only for trusted sources).
+*   const data = parseJsonSafe('{"__proto__":{}}', undefined, {
+*     allowPrototype: true,
+*   })
+*   ```
+*
+* @throws {Error} When `jsonString` exceeds `maxSize`.
+* @throws {Error} When JSON parsing fails.
+* @throws {Error} When prototype-pollution keys are detected (and
+*   `allowPrototype` is not `true`).
+* @throws {Error} When schema validation fails.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function parseJsonSafe(jsonString, schema, options = {}) {
-  const { allowPrototype = false, maxSize = DEFAULT_MAX_SIZE } = options;
-  const byteLength = (0, import_buffer.BufferByteLength)(jsonString, "utf8");
-  if (byteLength > maxSize) {
-    throw new import_error.ErrorCtor(
-      `JSON string exceeds maximum size limit${maxSize !== DEFAULT_MAX_SIZE ? ` of ${maxSize} bytes` : ""}`
-    );
-  }
-  let parsed;
-  try {
-    parsed = allowPrototype ? (0, import_json.JSONParse)(jsonString) : (0, import_json.JSONParse)(jsonString, prototypePollutionReviver);
-  } catch (e) {
-    throw new import_error.ErrorCtor(`Failed to parse JSON: ${e}`);
-  }
-  if (schema) {
-    const result = (0, import_validate.validateSchema)(schema, parsed);
-    if (!result.ok) {
-      const summary = result.errors.map((e) => `${e.path.join(".") || "(root)"}: ${e.message}`).join(", ");
-      throw new import_error.ErrorCtor(`Validation failed: ${summary}`);
-    }
-    return result.value;
-  }
-  return parsed;
+	const { allowPrototype = false, maxSize = DEFAULT_MAX_SIZE } = options;
+	if (require_primordials_buffer.BufferByteLength(jsonString, "utf8") > maxSize) throw new require_primordials_error.ErrorCtor(`JSON string exceeds maximum size limit${maxSize !== DEFAULT_MAX_SIZE ? ` of ${maxSize} bytes` : ""}`);
+	let parsed;
+	try {
+		parsed = allowPrototype ? require_primordials_json.JSONParse(jsonString) : require_primordials_json.JSONParse(jsonString, prototypePollutionReviver);
+	} catch (e) {
+		throw new require_primordials_error.ErrorCtor(`Failed to parse JSON: ${e}`);
+	}
+	if (schema) {
+		const result = require_schema_validate.validateSchema(schema, parsed);
+		if (!result.ok) throw new require_primordials_error.ErrorCtor(`Validation failed: ${result.errors.map((e) => `${e.path.join(".") || "(root)"}: ${e.message}`).join(", ")}`);
+		return result.value;
+	}
+	return parsed;
 }
+/**
+* JSON.parse reviver that rejects prototype pollution keys at any depth.
+*
+* @internal
+*/
 function prototypePollutionReviver(key, value) {
-  if (DANGEROUS_KEYS.has(key)) {
-    throw new import_error.ErrorCtor(
-      "JSON contains potentially malicious prototype pollution keys"
-    );
-  }
-  return value;
+	if (DANGEROUS_KEYS.has(key)) throw new require_primordials_error.ErrorCtor("JSON contains potentially malicious prototype pollution keys");
+	return value;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  isBuffer,
-  isJsonPrimitive,
-  parseJson,
-  parseJsonSafe,
-  prototypePollutionReviver
-});
+
+//#endregion
+exports.isBuffer = isBuffer;
+exports.isJsonPrimitive = isJsonPrimitive;
+exports.parseJson = parseJson;
+exports.parseJsonSafe = parseJsonSafe;
+exports.prototypePollutionReviver = prototypePollutionReviver;