@mnaoumov/typescript-lib 0.0.0 → 1.0.0

package/dist/lib/cjs/object-utils.cjs

@@ -0,0 +1,617 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"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 object_utils_exports = {};
+__export(object_utils_exports, {
+  FunctionHandlingMode: () => FunctionHandlingMode,
+  assignWithNonEnumerableProperties: () => assignWithNonEnumerableProperties,
+  castTo: () => castTo,
+  cloneWithNonEnumerableProperties: () => cloneWithNonEnumerableProperties,
+  deleteProperties: () => deleteProperties,
+  deleteProperty: () => deleteProperty,
+  extractDefaultExportInterop: () => extractDefaultExportInterop,
+  getAllEntries: () => getAllEntries,
+  getAllKeys: () => getAllKeys,
+  getNestedPropertyValue: () => getNestedPropertyValue,
+  getPrototypeOf: () => getPrototypeOf,
+  isDeepEqual: () => isDeepEqual,
+  nameof: () => nameof,
+  normalizeOptionalProperties: () => normalizeOptionalProperties,
+  removeUndefinedProperties: () => removeUndefinedProperties,
+  setNestedPropertyValue: () => setNestedPropertyValue,
+  toJson: () => toJson
+});
+module.exports = __toCommonJS(object_utils_exports);
+var import_error = require('./error.cjs');
+var import_function = require('./function.cjs');
+var import_reg_exp = require('./reg-exp.cjs');
+var import_string = require('./string.cjs');
+var import_type_guards = require('./type-guards.cjs');
+var FunctionHandlingMode = /* @__PURE__ */ ((FunctionHandlingMode2) => {
+  FunctionHandlingMode2["Exclude"] = "exclude";
+  FunctionHandlingMode2["Full"] = "full";
+  FunctionHandlingMode2["NameOnly"] = "nameOnly";
+  return FunctionHandlingMode2;
+})(FunctionHandlingMode || {});
+const KEY_SEPARATOR = ".";
+const PLACEHOLDER_KEY_PREFIX = "toJson:";
+const equalityComparerEntries = [
+  createEqualityComparerEntry(ArrayBuffer, isDeepEqualArrayBuffer),
+  createEqualityComparerEntry(Date, isDeepEqualDate),
+  createEqualityComparerEntry(RegExp, isDeepEqualRegExp),
+  createEqualityComparerEntry(Map, isDeepEqualMap),
+  createEqualityComparerEntry(Set, isDeepEqualSet)
+];
+class ToJsonConverter {
+  fullOptions;
+  functionTexts = [];
+  usedObjects = /* @__PURE__ */ new WeakSet();
+  /**
+   * Creates a new converter, resolving the provided options against the defaults.
+   *
+   * @param options - The options for the JSON conversion.
+   */
+  constructor(options) {
+    const DEFAULT_OPTIONS = {
+      functionHandlingMode: "exclude" /* Exclude */,
+      maxDepth: -1,
+      shouldCatchToJSONErrors: false,
+      shouldHandleCircularReferences: false,
+      shouldHandleErrors: false,
+      shouldHandleUndefined: false,
+      shouldSortKeys: false,
+      // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.
+      space: 2,
+      tokenSubstitutions: {
+        circularReference: makeObjectTokenSubstitution("CircularReference" /* CircularReference */),
+        maxDepthLimitReached: makeObjectTokenSubstitution("MaxDepthLimitReached" /* MaxDepthLimitReached */),
+        toJSONFailed: makeObjectTokenSubstitution("ToJSONFailed" /* ToJSONFailed */)
+      }
+    };
+    const fullOptions = {
+      ...DEFAULT_OPTIONS,
+      ...options,
+      tokenSubstitutions: {
+        ...DEFAULT_OPTIONS.tokenSubstitutions,
+        ...options.tokenSubstitutions
+      }
+    };
+    if (fullOptions.maxDepth === -1) {
+      fullOptions.maxDepth = Infinity;
+    }
+    this.fullOptions = fullOptions;
+  }
+  /**
+   * Converts the given value to a JSON string, applying the configured token substitutions.
+   *
+   * @param value - The value to convert.
+   * @returns The JSON string representation of the value.
+   */
+  convert(value) {
+    const plainObject = this.toPlainObject({
+      canUseToJSON: true,
+      depth: 0,
+      key: "",
+      value
+    });
+    let json = (0, import_type_guards.ensureNonNullable)(JSON.stringify(plainObject, null, this.fullOptions.space));
+    const placeholderRegExp = new RegExp(String.raw`"\[\[${(0, import_reg_exp.escapeRegExp)(PLACEHOLDER_KEY_PREFIX)}(?<Key>[A-Za-z]+)(?<Index>\d*)\]\]"`, "g");
+    json = (0, import_string.replaceAll)({
+      $string: json,
+      replacer: ({ capturedGroupArguments: [key = "", indexString = ""] }) => applySubstitutions({
+        functionTexts: this.functionTexts,
+        index: indexString ? parseInt(indexString, 10) : 0,
+        key: castTo(key),
+        substitutions: this.fullOptions.tokenSubstitutions
+      }),
+      searchValue: placeholderRegExp
+    });
+    return json;
+  }
+  handleArray(params) {
+    const {
+      canUseToJSON,
+      depth,
+      value
+    } = params;
+    return depth > this.fullOptions.maxDepth ? makePlaceholder("MaxDepthLimitReachedArray" /* MaxDepthLimitReachedArray */, value.length) : value.map(
+      (item, index) => this.toPlainObject({
+        canUseToJSON,
+        depth: depth + 1,
+        key: String(index),
+        value: item
+      })
+    );
+  }
+  handleCircularReference(value, key) {
+    if (this.fullOptions.shouldHandleCircularReferences) {
+      return makePlaceholder("CircularReference" /* CircularReference */);
+    }
+    const valueConstructorName = value.constructor.name || "Object";
+    throw new TypeError(`Converting circular structure to JSON
+--> starting at object with constructor '${valueConstructorName}'
+--- property '${key}' closes the circle`);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- We need to use `Function` type to handle them separately.
+  handleFunction(value) {
+    if (this.fullOptions.functionHandlingMode === "exclude" /* Exclude */) {
+      return void 0;
+    }
+    const index = this.functionTexts.length;
+    const functionText = this.fullOptions.functionHandlingMode === "full" /* Full */ ? (0, import_function.getFunctionExpressionString)(value) : `function ${value.name || "anonymous"}() { /* ... */ }`;
+    this.functionTexts.push(functionText);
+    return makePlaceholder("Function" /* Function */, index);
+  }
+  handleObject(params) {
+    const {
+      canUseToJSON,
+      depth,
+      key,
+      value
+    } = params;
+    if (this.usedObjects.has(value)) {
+      return this.handleCircularReference(value, key);
+    }
+    this.usedObjects.add(value);
+    if (canUseToJSON) {
+      const toJSONResult = this.tryHandleToJSON({
+        depth,
+        key,
+        value
+      });
+      if (toJSONResult !== void 0) {
+        return toJSONResult;
+      }
+    }
+    if (Array.isArray(value)) {
+      return this.handleArray({
+        canUseToJSON,
+        depth,
+        value
+      });
+    }
+    if (depth > this.fullOptions.maxDepth) {
+      return makePlaceholder("MaxDepthLimitReached" /* MaxDepthLimitReached */);
+    }
+    return value instanceof Error && this.fullOptions.shouldHandleErrors ? (0, import_error.errorToString)(value) : this.handlePlainObject({
+      canUseToJSON,
+      depth,
+      value
+    });
+  }
+  handlePlainObject(params) {
+    const {
+      canUseToJSON,
+      depth,
+      value
+    } = params;
+    const entries = Object.entries(value);
+    if (this.fullOptions.shouldSortKeys) {
+      entries.sort(([key1], [key2]) => key1.localeCompare(key2));
+    }
+    return Object.fromEntries(
+      entries.map(([key2, value2]) => [
+        key2,
+        this.toPlainObject({
+          canUseToJSON,
+          depth: depth + 1,
+          key: key2,
+          value: value2
+        })
+      ])
+    );
+  }
+  toPlainObject(params) {
+    const {
+      canUseToJSON,
+      depth,
+      key,
+      value
+    } = params;
+    if (value === void 0) {
+      return depth === 0 || this.fullOptions.shouldHandleUndefined ? makePlaceholder("Undefined" /* Undefined */) : void 0;
+    }
+    if (typeof value === "function") {
+      return this.handleFunction(value);
+    }
+    return typeof value !== "object" || value === null ? value : this.handleObject({
+      canUseToJSON,
+      depth,
+      key,
+      value
+    });
+  }
+  tryHandleToJSON(params) {
+    const {
+      depth,
+      key,
+      value
+    } = params;
+    const toJSON = value.toJSON;
+    if (typeof toJSON === "function") {
+      try {
+        const newValue = toJSON.call(value, key);
+        return this.toPlainObject({
+          canUseToJSON: false,
+          depth,
+          key,
+          value: newValue
+        });
+      } catch (error) {
+        if (this.fullOptions.shouldCatchToJSONErrors) {
+          return makePlaceholder("ToJSONFailed" /* ToJSONFailed */);
+        }
+        throw error;
+      }
+    }
+    return void 0;
+  }
+}
+function assignWithNonEnumerableProperties(target, ...sources) {
+  return assignWithNonEnumerablePropertiesImpl(target, ...sources);
+}
+function castTo(value) {
+  return value;
+}
+function cloneWithNonEnumerableProperties($object) {
+  return Object.create(getPrototypeOf($object), Object.getOwnPropertyDescriptors($object));
+}
+function deleteProperties($object, propertyNames) {
+  let hasDeletedAny = false;
+  for (const propertyName of propertyNames) {
+    hasDeletedAny = deleteProperty($object, propertyName) || hasDeletedAny;
+  }
+  return hasDeletedAny;
+}
+function deleteProperty($object, propertyName) {
+  if (!Object.hasOwn($object, propertyName)) {
+    return false;
+  }
+  delete $object[propertyName];
+  return true;
+}
+function extractDefaultExportInterop(module2) {
+  if (typeof module2 !== "object" || module2 === null) {
+    return module2;
+  }
+  return "default" in module2 ? module2.default : module2;
+}
+function getAllEntries($object) {
+  return getAllKeys($object).map((key) => [key, $object[key]]);
+}
+function getAllKeys($object) {
+  const keys = [];
+  let current = $object;
+  while (current) {
+    const descriptors = Object.getOwnPropertyDescriptors(current);
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+      if (key === "__proto__" || typeof descriptor.value === "function") {
+        continue;
+      }
+      const hasGetter = typeof descriptor.get === "function";
+      const hasSetter = typeof descriptor.set === "function";
+      if (hasGetter || hasSetter) {
+        if (hasGetter && hasSetter) {
+          keys.push(key);
+        }
+        continue;
+      }
+      if (descriptor.enumerable && descriptor.writable) {
+        keys.push(key);
+      }
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  return keys.sort();
+}
+function getNestedPropertyValue($object, path) {
+  let node = $object;
+  const keys = path.split(KEY_SEPARATOR);
+  for (const key of keys) {
+    if (node === void 0) {
+      return void 0;
+    }
+    node = node[key];
+  }
+  return node;
+}
+function getPrototypeOf(instance) {
+  return instance === void 0 || instance === null ? instance : Object.getPrototypeOf(instance);
+}
+function isDeepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return false;
+  }
+  const aConstructor = a.constructor;
+  const bConstructor = b.constructor;
+  if (aConstructor !== bConstructor) {
+    return false;
+  }
+  if (aConstructor !== Object) {
+    const result = deepEqualTyped(a, b);
+    if (result !== void 0) {
+      return result;
+    }
+  }
+  const keysA = getAllKeys(a);
+  const keysB = getAllKeys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  const aRecord = (0, import_type_guards.ensureGenericObject)(a);
+  const bRecord = (0, import_type_guards.ensureGenericObject)(b);
+  for (const key of keysA) {
+    if (!keysB.includes(key) || !isDeepEqual(aRecord[key], bRecord[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function nameof(name) {
+  return name;
+}
+function normalizeOptionalProperties($object) {
+  return $object;
+}
+function removeUndefinedProperties($object, keysToKeep) {
+  for (const [key, value] of Object.entries($object)) {
+    if (value === void 0 && !keysToKeep?.includes(key)) {
+      delete $object[key];
+    }
+  }
+  return $object;
+}
+function setNestedPropertyValue(params) {
+  const {
+    $object,
+    path,
+    value
+  } = params;
+  const error = new Error(`Property path ${path} not found`);
+  let node = $object;
+  const keys = path.split(KEY_SEPARATOR);
+  for (const key of keys.slice(0, -1)) {
+    if (node === void 0) {
+      throw error;
+    }
+    node = node[key];
+  }
+  const lastKey = (0, import_type_guards.ensureNonNullable)(keys.at(-1));
+  if (node === void 0) {
+    throw error;
+  }
+  node[lastKey] = value;
+}
+function toJson(value, options = {}) {
+  return new ToJsonConverter(options).convert(value);
+}
+function applySubstitutions(params) {
+  switch (params.key) {
+    case "CircularReference" /* CircularReference */: {
+      return params.substitutions.circularReference;
+    }
+    case "Function" /* Function */: {
+      return (0, import_type_guards.ensureNonNullable)(params.functionTexts[params.index], `Function with index ${String(params.index)} not found`);
+    }
+    case "MaxDepthLimitReached" /* MaxDepthLimitReached */: {
+      return params.substitutions.maxDepthLimitReached;
+    }
+    case "MaxDepthLimitReachedArray" /* MaxDepthLimitReachedArray */: {
+      return `Array(${String(params.index)})`;
+    }
+    case "ToJSONFailed" /* ToJSONFailed */: {
+      return params.substitutions.toJSONFailed;
+    }
+    case "Undefined" /* Undefined */: {
+      return "undefined";
+    }
+    /* v8 ignore start -- Exhaustive switch guard; default branch is unreachable. */
+    default: {
+      (0, import_type_guards.assertNever)(params.key);
+    }
+  }
+}
+function assignWithNonEnumerablePropertiesImpl(target, ...sources) {
+  for (const source of sources) {
+    const descriptors = Object.getOwnPropertyDescriptors(source);
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+      try {
+        if (key === "prototype" || Object.getOwnPropertyDescriptor(target, key)?.writable === false && !Object.getOwnPropertyDescriptor(target, key)?.configurable) {
+          continue;
+        }
+        Object.defineProperty(target, key, descriptor);
+      } catch {
+      }
+    }
+  }
+  const sourcePrototypes = sources.map((source) => getPrototypeOf(source)).filter((prototype) => !!prototype);
+  if (sourcePrototypes.length > 0) {
+    const targetPrototype = assignWithNonEnumerablePropertiesImpl({}, getPrototypeOf(target), ...sourcePrototypes);
+    try {
+      Object.setPrototypeOf(target, targetPrototype);
+    } catch {
+    }
+  }
+  return target;
+}
+function createEqualityComparerEntry(constructor, checkIsEqual) {
+  return {
+    constructor,
+    equalityComparer: (a, b) => checkIsEqual(a, b)
+  };
+}
+function deepEqualTyped(a, b) {
+  for (const entry of equalityComparerEntries) {
+    const result = tryEntryEquality({
+      a,
+      b,
+      entry
+    });
+    if (result !== void 0) {
+      return result;
+    }
+  }
+  return void 0;
+}
+function isDeepEqualArrayBuffer(a, b) {
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+  const viewA = new Uint8Array(a);
+  const viewB = new Uint8Array(b);
+  return isDeepEqual(viewA, viewB);
+}
+function isDeepEqualDate(a, b) {
+  return a.getTime() === b.getTime();
+}
+function isDeepEqualMap(a, b) {
+  if (a.size !== b.size) {
+    return false;
+  }
+  for (const [key, value] of a) {
+    if (!b.has(key) || !isDeepEqual(value, b.get(key))) {
+      return false;
+    }
+  }
+  return true;
+}
+function isDeepEqualRegExp(a, b) {
+  return a.source === b.source && a.flags === b.flags;
+}
+function isDeepEqualSet(a, b) {
+  if (a.size !== b.size) {
+    return false;
+  }
+  for (const valueA of a) {
+    if (b.has(valueA)) {
+      continue;
+    }
+    let hasMatch = false;
+    for (const valueB of b) {
+      if (isDeepEqual(valueA, valueB)) {
+        hasMatch = true;
+        break;
+      }
+    }
+    if (!hasMatch) {
+      return false;
+    }
+  }
+  return true;
+}
+function makeObjectTokenSubstitution(key) {
+  return `{ "[[${key}]]": null }`;
+}
+function makePlaceholder(key, index) {
+  return `[[${PLACEHOLDER_KEY_PREFIX}${key}${index ? String(index) : ""}]]`;
+}
+function tryEntryEquality(params) {
+  const {
+    a,
+    b,
+    entry
+  } = params;
+  return a instanceof entry.constructor && b instanceof entry.constructor ? entry.equalityComparer(a, b) : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FunctionHandlingMode,
+  assignWithNonEnumerableProperties,
+  castTo,
+  cloneWithNonEnumerableProperties,
+  deleteProperties,
+  deleteProperty,
+  extractDefaultExportInterop,
+  getAllEntries,
+  getAllKeys,
+  getNestedPropertyValue,
+  getPrototypeOf,
+  isDeepEqual,
+  nameof,
+  normalizeOptionalProperties,
+  removeUndefinedProperties,
+  setNestedPropertyValue,
+  toJson
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/object-utils.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for Objects.\n */\n\nimport type {\n  Constructor,\n  RequiredKeysOf,\n  UndefinedOnPartialDeep\n} from 'type-fest';\n\nimport type { GenericObject } from './type-guards.ts';\nimport type {\n  ExactMembers,\n  MaybeReturn,\n  StringKeys\n} from './type.ts';\n\nimport { errorToString } from './error.ts';\nimport { getFunctionExpressionString } from './function.ts';\nimport { escapeRegExp } from './reg-exp.ts';\nimport { replaceAll } from './string.ts';\nimport {\n  assertNever,\n  ensureGenericObject,\n  ensureNonNullable\n} from './type-guards.ts';\n\n/**\n * Specifies how functions should be handled in the JSON output.\n */\nexport enum FunctionHandlingMode {\n  /**\n   * Excludes functions from the JSON output.\n   */\n  Exclude = 'exclude',\n  /**\n   * Includes the full function definition in the JSON output.\n   */\n  Full = 'full',\n  /**\n   * Includes only the function name in the JSON output.\n   */\n  NameOnly = 'nameOnly'\n}\n\nenum TokenSubstitutionKey {\n  CircularReference = 'CircularReference',\n  Function = 'Function',\n  MaxDepthLimitReached = 'MaxDepthLimitReached',\n  MaxDepthLimitReachedArray = 'MaxDepthLimitReachedArray',\n  ToJSONFailed = 'ToJSONFailed',\n  Undefined = 'Undefined'\n}\n\n/**\n * Options for {@link toJson}.\n */\nexport interface ToJsonOptions {\n  /**\n   * Specifies how functions should be handled in the JSON output.\n   *\n   * @default {@link FunctionHandlingMode.Exclude}\n   */\n  readonly functionHandlingMode: FunctionHandlingMode;\n\n  /**\n   * Specifies the maximum depth of nested objects to include in the JSON output.\n   * Use `-1` for no limit.\n   *\n   * @default `-1`\n   */\n  readonly maxDepth: number;\n\n  /**\n   * Specifies whether to catch errors in `toJSON()` and replace them with a placeholder.\n   *\n   * @default `false`\n   */\n  readonly shouldCatchToJSONErrors: boolean;\n\n  /**\n   * Specifies whether to handle circular references in the JSON output.\n   *\n   * @default `false`\n   */\n  readonly shouldHandleCircularReferences: boolean;\n\n  /**\n   * Specifies whether to handle errors in the JSON output.\n   *\n   * @default `false`\n   */\n  readonly shouldHandleErrors: boolean;\n\n  /**\n   * Specifies whether to handle `undefined` values in the JSON output.\n   *\n   * @default `false`\n   */\n  readonly shouldHandleUndefined: boolean;\n\n  /**\n   * Specifies whether to sort the keys of the JSON output.\n   *\n   * @default `false`\n   */\n  readonly shouldSortKeys: boolean;\n\n  /**\n   * Specifies the indentation of the JSON output. This can be a number of spaces or a string.\n   *\n   * @default `2`\n   */\n  readonly space: number | string;\n\n  /**\n   * Specifies the substitutions to use in the JSON output.\n   */\n  readonly tokenSubstitutions: Partial<TokenSubstitutions>;\n}\n\ninterface ApplySubstitutionsParams {\n  readonly functionTexts: readonly string[];\n  readonly index: number;\n  readonly key: TokenSubstitutionKey;\n  readonly substitutions: TokenSubstitutions;\n}\n\ninterface EqualityComparerEntry<T> {\n  constructor: Constructor<T>;\n  equalityComparer: (a: T, b: T) => boolean;\n}\n\ninterface JSONSerializable {\n  toJSON: (...$arguments: unknown[]) => unknown;\n}\n\ninterface ModuleWithDefaultExport<T> {\n  default: T;\n}\n\ninterface ResolvedToJsonOptions extends ToJsonOptions {\n  readonly tokenSubstitutions: TokenSubstitutions;\n}\n\ninterface TokenSubstitutions {\n  circularReference: string;\n  maxDepthLimitReached: string;\n  toJSONFailed: string;\n}\n\nconst KEY_SEPARATOR = '.';\nconst PLACEHOLDER_KEY_PREFIX = 'toJson:';\nconst equalityComparerEntries: readonly EqualityComparerEntry<unknown>[] = [\n  createEqualityComparerEntry(ArrayBuffer, isDeepEqualArrayBuffer),\n  createEqualityComparerEntry(Date, isDeepEqualDate),\n  createEqualityComparerEntry(RegExp, isDeepEqualRegExp),\n  createEqualityComparerEntry<Map<unknown, unknown>>(Map, isDeepEqualMap),\n  createEqualityComparerEntry<Set<unknown>>(Set, isDeepEqualSet)\n];\n\n/**\n * Parameters for {@link setNestedPropertyValue}.\n */\nexport interface SetNestedPropertyValueParams {\n  /**\n   * The object to set the nested property value in.\n   */\n  readonly $object: GenericObject;\n\n  /**\n   * The path to the nested property.\n   */\n  readonly path: string;\n\n  /**\n   * The value to set.\n   */\n  readonly value: unknown;\n}\n\ninterface HandleArrayParams {\n  /**\n   * Whether `toJSON()` may be used during conversion.\n   */\n  readonly canUseToJSON: boolean;\n\n  /**\n   * The current recursion depth.\n   */\n  readonly depth: number;\n\n  /**\n   * The array value to convert.\n   */\n  readonly value: unknown[];\n}\n\ninterface HandleObjectParams {\n  /**\n   * Whether `toJSON()` may be used during conversion.\n   */\n  readonly canUseToJSON: boolean;\n\n  /**\n   * The current recursion depth.\n   */\n  readonly depth: number;\n\n  /**\n   * The key under which the value is stored in its parent.\n   */\n  readonly key: string;\n\n  /**\n   * The object value to convert.\n   */\n  readonly value: object;\n}\n\ninterface HandlePlainObjectParams {\n  /**\n   * Whether `toJSON()` may be used during conversion.\n   */\n  readonly canUseToJSON: boolean;\n\n  /**\n   * The current recursion depth.\n   */\n  readonly depth: number;\n\n  /**\n   * The plain object value to convert.\n   */\n  readonly value: object;\n}\n\ntype KeysWithUndefined<T> = KeysWithUndefinedMap<T>[keyof T];\n\ntype KeysWithUndefinedMap<T> = {\n  [K in keyof T]-?: undefined extends T[K] ? K : never;\n};\ntype MandatoryKeysWithUndefined<T extends object> = Extract<RequiredKeysOf<T> & StringKeys<T>, KeysWithUndefined<T>>;\ntype RemoveUndefinedOverload<T extends object> = MandatoryKeysWithUndefined<T> extends never ? [obj: T]\n  : never;\n\ntype RemoveUndefinedWithKeysOverload<T extends object, K extends readonly string[]> = [obj: T, keysToKeep: ExactMembers<MandatoryKeysWithUndefined<T>, K>];\n\ninterface ToPlainObjectParams {\n  /**\n   * Whether `toJSON()` may be used during conversion.\n   */\n  readonly canUseToJSON: boolean;\n\n  /**\n   * The current recursion depth.\n   */\n  readonly depth: number;\n\n  /**\n   * The key under which the value is stored in its parent.\n   */\n  readonly key: string;\n\n  /**\n   * The value to convert.\n   */\n  readonly value: unknown;\n}\n\n/**\n * Parameters for {@link tryEntryEquality}.\n */\ninterface TryEntryEqualityParams {\n  /**\n   * The first value to compare.\n   */\n  readonly a: unknown;\n\n  /**\n   * The second value to compare.\n   */\n  readonly b: unknown;\n\n  /**\n   * The equality comparer entry to use.\n   */\n  readonly entry: EqualityComparerEntry<unknown>;\n}\n\ninterface TryHandleToJSONParams {\n  /**\n   * The current recursion depth.\n   */\n  readonly depth: number;\n\n  /**\n   * The key under which the value is stored in its parent.\n   */\n  readonly key: string;\n\n  /**\n   * The object value to convert.\n   */\n  readonly value: object;\n}\n\n/**\n * Converts a value to a JSON-serializable plain object and renders it as a JSON string.\n *\n * A fresh instance is created per {@link toJson} call so that the accumulated `functionTexts`\n * and the `usedObjects` circular-reference set never leak between conversions.\n */\nclass ToJsonConverter {\n  private readonly fullOptions: ResolvedToJsonOptions;\n  private readonly functionTexts: string[] = [];\n  private readonly usedObjects = new WeakSet();\n\n  /**\n   * Creates a new converter, resolving the provided options against the defaults.\n   *\n   * @param options - The options for the JSON conversion.\n   */\n  public constructor(options: Partial<ToJsonOptions>) {\n    const DEFAULT_OPTIONS: ResolvedToJsonOptions = {\n      functionHandlingMode: FunctionHandlingMode.Exclude,\n      maxDepth: -1,\n      shouldCatchToJSONErrors: false,\n      shouldHandleCircularReferences: false,\n      shouldHandleErrors: false,\n      shouldHandleUndefined: false,\n      shouldSortKeys: false,\n      // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n      space: 2,\n      tokenSubstitutions: {\n        circularReference: makeObjectTokenSubstitution(TokenSubstitutionKey.CircularReference),\n        maxDepthLimitReached: makeObjectTokenSubstitution(TokenSubstitutionKey.MaxDepthLimitReached),\n        toJSONFailed: makeObjectTokenSubstitution(TokenSubstitutionKey.ToJSONFailed)\n      }\n    };\n\n    const fullOptions = {\n      ...DEFAULT_OPTIONS,\n      ...options,\n      tokenSubstitutions: {\n        ...DEFAULT_OPTIONS.tokenSubstitutions,\n        ...options.tokenSubstitutions\n      }\n    };\n\n    if (fullOptions.maxDepth === -1) {\n      fullOptions.maxDepth = Infinity;\n    }\n\n    this.fullOptions = fullOptions;\n  }\n\n  /**\n   * Converts the given value to a JSON string, applying the configured token substitutions.\n   *\n   * @param value - The value to convert.\n   * @returns The JSON string representation of the value.\n   */\n  public convert(value: unknown): string {\n    const plainObject = this.toPlainObject({\n      canUseToJSON: true,\n      depth: 0,\n      key: '',\n      value\n    });\n    let json = ensureNonNullable(JSON.stringify(plainObject, null, this.fullOptions.space));\n    const placeholderRegExp = new RegExp(String.raw`\"\\[\\[${escapeRegExp(PLACEHOLDER_KEY_PREFIX)}(?<Key>[A-Za-z]+)(?<Index>\\d*)\\]\\]\"`, 'g');\n    json = replaceAll({\n      $string: json,\n      replacer: ({ capturedGroupArguments: [key = '', indexString = ''] }) =>\n        applySubstitutions({\n          functionTexts: this.functionTexts,\n          index: indexString ? parseInt(indexString, 10) : 0,\n          key: castTo<TokenSubstitutionKey>(key),\n          substitutions: this.fullOptions.tokenSubstitutions\n        }),\n      searchValue: placeholderRegExp\n    });\n    return json;\n  }\n\n  private handleArray(params: HandleArrayParams): unknown {\n    const {\n      canUseToJSON,\n      depth,\n      value\n    } = params;\n    return depth > this.fullOptions.maxDepth\n      ? makePlaceholder(TokenSubstitutionKey.MaxDepthLimitReachedArray, value.length)\n      : value.map((item, index) =>\n        this.toPlainObject({\n          canUseToJSON,\n          depth: depth + 1,\n          key: String(index),\n          value: item\n        })\n      );\n  }\n\n  private handleCircularReference(value: object, key: string): unknown {\n    if (this.fullOptions.shouldHandleCircularReferences) {\n      return makePlaceholder(TokenSubstitutionKey.CircularReference);\n    }\n    const valueConstructorName = value.constructor.name || 'Object';\n    throw new TypeError(`Converting circular structure to JSON\n--> starting at object with constructor '${valueConstructorName}'\n--- property '${key}' closes the circle`);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- We need to use `Function` type to handle them separately.\n  private handleFunction(value: Function): unknown {\n    if (this.fullOptions.functionHandlingMode === FunctionHandlingMode.Exclude) {\n      return undefined;\n    }\n    const index = this.functionTexts.length;\n    const functionText = this.fullOptions.functionHandlingMode === FunctionHandlingMode.Full\n      ? getFunctionExpressionString(value)\n      : `function ${value.name || 'anonymous'}() { /* ... */ }`;\n    this.functionTexts.push(functionText);\n    return makePlaceholder(TokenSubstitutionKey.Function, index);\n  }\n\n  private handleObject(params: HandleObjectParams): unknown {\n    const {\n      canUseToJSON,\n      depth,\n      key,\n      value\n    } = params;\n    if (this.usedObjects.has(value)) {\n      return this.handleCircularReference(value, key);\n    }\n\n    this.usedObjects.add(value);\n\n    if (canUseToJSON) {\n      const toJSONResult = this.tryHandleToJSON({\n        depth,\n        key,\n        value\n      });\n      if (toJSONResult !== undefined) {\n        return toJSONResult;\n      }\n    }\n\n    if (Array.isArray(value)) {\n      return this.handleArray({\n        canUseToJSON,\n        depth,\n        value\n      });\n    }\n\n    if (depth > this.fullOptions.maxDepth) {\n      return makePlaceholder(TokenSubstitutionKey.MaxDepthLimitReached);\n    }\n\n    return value instanceof Error && this.fullOptions.shouldHandleErrors\n      ? errorToString(value)\n      : this.handlePlainObject({\n        canUseToJSON,\n        depth,\n        value\n      });\n  }\n\n  private handlePlainObject(params: HandlePlainObjectParams): unknown {\n    const {\n      canUseToJSON,\n      depth,\n      value\n    } = params;\n    const entries = Object.entries(value);\n    if (this.fullOptions.shouldSortKeys) {\n      entries.sort(([key1], [key2]) => key1.localeCompare(key2));\n    }\n\n    return Object.fromEntries(\n      entries.map(([key2, value2]) => [\n        key2,\n        this.toPlainObject({\n          canUseToJSON,\n          depth: depth + 1,\n          key: key2,\n          value: value2\n        })\n      ])\n    );\n  }\n\n  private toPlainObject(params: ToPlainObjectParams): unknown {\n    const {\n      canUseToJSON,\n      depth,\n      key,\n      value\n    } = params;\n    if (value === undefined) {\n      return (depth === 0 || this.fullOptions.shouldHandleUndefined)\n        ? makePlaceholder(TokenSubstitutionKey.Undefined)\n        : undefined;\n    }\n\n    if (typeof value === 'function') {\n      return this.handleFunction(value);\n    }\n\n    return typeof value !== 'object' || value === null\n      ? value\n      : this.handleObject({\n        canUseToJSON,\n        depth,\n        key,\n        value\n      });\n  }\n\n  private tryHandleToJSON(params: TryHandleToJSONParams): unknown {\n    const {\n      depth,\n      key,\n      value\n    } = params;\n    const toJSON = (value as Partial<JSONSerializable>).toJSON;\n    if (typeof toJSON === 'function') {\n      try {\n        const newValue = toJSON.call(value, key);\n        return this.toPlainObject({\n          canUseToJSON: false,\n          depth,\n          key,\n          value: newValue\n        });\n      } catch (error) {\n        if (this.fullOptions.shouldCatchToJSONErrors) {\n          return makePlaceholder(TokenSubstitutionKey.ToJSONFailed);\n        }\n        throw error;\n      }\n    }\n    return undefined;\n  }\n}\n/**\n * Assigns properties from one or more source objects to a target object, including non-enumerable properties.\n *\n * @typeParam T - The target object type.\n * @typeParam U - The source object type.\n * @param target - The target object to assign properties to.\n * @param source - The source object to assign properties from.\n * @returns The target object with the assigned properties.\n */\nexport function assignWithNonEnumerableProperties<T extends object, U>(target: T, source: U): T & U;\n/**\n * Assigns properties from one or more source objects to a target object, including non-enumerable properties.\n *\n * @typeParam T - The target object type.\n * @typeParam U - The first source object type.\n * @typeParam V - The second source object type.\n * @param target - The target object to assign properties to.\n * @param source1 - The first source object to assign properties from.\n * @param source2 - The second source object to assign properties from.\n * @returns The target object with the assigned properties.\n */\nexport function assignWithNonEnumerableProperties<T extends object, U, V>(target: T, source1: U, source2: V): T & U & V;\n/**\n * Assigns properties from one or more source objects to a target object, including non-enumerable properties.\n *\n * @typeParam T - The target object type.\n * @typeParam U - The first source object type.\n * @typeParam V - The second source object type.\n * @typeParam W - The third source object type.\n * @param target - The target object to assign properties to.\n * @param source1 - The first source object to assign properties from.\n * @param source2 - The second source object to assign properties from.\n * @param source3 - The third source object to assign properties from.\n * @returns The target object with the assigned properties.\n */\nexport function assignWithNonEnumerableProperties<T extends object, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;\n/**\n * Assigns properties from one or more source objects to a target object, including non-enumerable properties.\n *\n * @param target - The target object to assign properties to.\n * @param sources - The source objects to assign properties from.\n * @returns The target object with the assigned properties.\n */\nexport function assignWithNonEnumerableProperties(target: object, ...sources: object[]): object {\n  return assignWithNonEnumerablePropertiesImpl(target, ...sources);\n}\n\n/**\n * Casts a value to a specific type.\n *\n * @typeParam T - The target type to cast to.\n * @param value - The value to cast.\n * @returns The value as the specified type.\n */\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to cast.\nexport function castTo<T>(value: unknown): T {\n  return value as T;\n}\n\n/**\n * Clones an object, including non-enumerable properties.\n *\n * @typeParam T - The type of the object.\n * @param $object - The object to clone.\n * @returns A new object with the same properties as the original object, including non-enumerable properties.\n */\nexport function cloneWithNonEnumerableProperties<T extends object>($object: T): T {\n  return Object.create(getPrototypeOf($object), Object.getOwnPropertyDescriptors($object)) as T;\n}\n\n/**\n * Deletes multiple properties from an object.\n *\n * @typeParam T - The type of the object.\n * @param $object - The object to delete the properties from.\n * @param propertyNames - The names of the properties to delete.\n * @returns `true` if any of the properties were present, otherwise `false`.\n */\n// eslint-disable-next-line unicorn/consistent-boolean-name -- The name states the action; the boolean only reports whether anything was deleted.\nexport function deleteProperties<T extends object>($object: T, propertyNames: (keyof T)[]): boolean {\n  let hasDeletedAny = false;\n\n  for (const propertyName of propertyNames) {\n    hasDeletedAny = deleteProperty($object, propertyName) || hasDeletedAny;\n  }\n\n  return hasDeletedAny;\n}\n\n/**\n * Deletes a property from an object.\n *\n * @typeParam T - The type of the object.\n * @param $object - The object to delete the property from.\n * @param propertyName - The name of the property to delete.\n * @returns `true` if the property was present, otherwise `false`.\n */\n// eslint-disable-next-line unicorn/consistent-boolean-name -- The name states the action; the boolean only reports whether the property was deleted.\nexport function deleteProperty<T extends object>($object: T, propertyName: keyof T): boolean {\n  if (!Object.hasOwn($object, propertyName)) {\n    return false;\n  }\n  // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- We have no other way to delete the property.\n  delete $object[propertyName];\n  return true;\n}\n\n/**\n * Extracts the default export from a module.\n *\n * Useful to handle incorrect default export interop between ESM and CJS.\n *\n * @typeParam T - The type of the default export.\n * @param module - The module to extract the default export from.\n * @returns The default export.\n */\nexport function extractDefaultExportInterop<T>(module: ModuleWithDefaultExport<T> | T): T {\n  if (typeof module !== 'object' || module === null) {\n    return module;\n  }\n\n  return 'default' in module ? module.default : module;\n}\n\n/**\n * Gets all entries of an object.\n *\n * @typeParam T - The type of the object.\n * @param $object - The object to get the entries of.\n * @returns An array of all entries of the object.\n */\nexport function getAllEntries<T extends object>($object: T): [StringKeys<T>, T[StringKeys<T>]][] {\n  return getAllKeys($object).map((key) => [key, $object[key]]);\n}\n\n/**\n * Gets all keys of an object.\n * Includes fields and properties.\n *\n * @typeParam T - The type of the object.\n * @param $object - The object to get the keys of.\n * @returns An array of all keys of the object.\n */\nexport function getAllKeys<T extends object>($object: T): StringKeys<T>[] {\n  const keys: StringKeys<T>[] = [];\n  let current: null | object = $object;\n  while (current) {\n    const descriptors = Object.getOwnPropertyDescriptors(current);\n    for (const [key, descriptor] of Object.entries(descriptors)) {\n      if ((key === '__proto__') || (typeof descriptor.value === 'function')) {\n        continue;\n      }\n\n      const hasGetter = typeof descriptor.get === 'function';\n      const hasSetter = typeof descriptor.set === 'function';\n      if (hasGetter || hasSetter) {\n        if (hasGetter && hasSetter) {\n          keys.push(key as StringKeys<T>);\n        }\n        continue;\n      }\n\n      if (descriptor.enumerable && descriptor.writable) {\n        keys.push(key as StringKeys<T>);\n      }\n    }\n\n    current = Object.getPrototypeOf(current) as null | object;\n  }\n  return keys.sort();\n}\n\n/**\n * Gets the value of a nested property from an object.\n *\n * @param $object - The object to get the nested property value from.\n * @param path - The path to the nested property.\n * @returns The value of the nested property.\n */\nexport function getNestedPropertyValue($object: GenericObject, path: string): unknown {\n  let node: GenericObject | undefined = $object;\n  const keys = path.split(KEY_SEPARATOR);\n  for (const key of keys) {\n    if (node === undefined) {\n      return undefined;\n    }\n    node = node[key] as GenericObject | undefined;\n  }\n\n  return node;\n}\n\n/**\n * Gets the prototype of the specified object.\n *\n * @typeParam T - The type of the object.\n * @param instance - The object instance to retrieve the prototype of.\n * @returns The prototype of the object.\n */\nexport function getPrototypeOf<T>(instance: T): T {\n  return instance === undefined || instance === null ? instance : (Object.getPrototypeOf(instance) as T);\n}\n\n/**\n * Compares two values to determine if they are deeply equal.\n *\n * @param a - The first value to compare.\n * @param b - The second value to compare.\n * @returns `true` if the values are deeply equal, otherwise `false`.\n */\nexport function isDeepEqual(a: unknown, b: unknown): boolean {\n  if (a === b) {\n    return true;\n  }\n\n  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) {\n    return false;\n  }\n\n  const aConstructor = a.constructor;\n  const bConstructor = b.constructor;\n\n  if (aConstructor !== bConstructor) {\n    return false;\n  }\n\n  if (aConstructor !== Object) {\n    const result = deepEqualTyped(a, b);\n    if (result !== undefined) {\n      return result;\n    }\n  }\n\n  const keysA = getAllKeys(a);\n  const keysB = getAllKeys(b);\n\n  if (keysA.length !== keysB.length) {\n    return false;\n  }\n\n  const aRecord = ensureGenericObject(a);\n  const bRecord = ensureGenericObject(b);\n\n  for (const key of keysA) {\n    if (!keysB.includes(key) || !isDeepEqual(aRecord[key], bRecord[key])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n/**\n * Retrieves the name of a property of a given type `T`.\n *\n * @typeParam T - The type of the object containing the property.\n * @param name - The name of the property as a string.\n * @returns The name of the property.\n */\nexport function nameof<T extends object>(name: StringKeys<T>): StringKeys<T> {\n  return name;\n}\n/**\n * Normalizes optional properties to allow `undefined` assignment in strict mode.\n *\n * This utility provides a workaround for the `exactOptionalPropertyTypes` TypeScript flag,\n * which prohibits directly assigning `undefined` to optional properties when the type\n * explicitly omits `undefined`.\n *\n * Example:\n * ```typescript\n * // With `exactOptionalPropertyTypes: true`\n * const x: { prop?: string } = { prop: undefined }; // Compiler error\n *\n * // Using this utility:\n * const y: { prop?: string } = normalizeOptionalProperties<{ prop?: string }>({ prop: undefined }); // Works\n * ```\n *\n * @typeParam T - The target type with optional properties to normalize.\n * @param $object - The object to normalize, allowing explicit `undefined` for optional properties.\n * @returns The normalized object, compatible with `exactOptionalPropertyTypes`.\n */\nexport function normalizeOptionalProperties<T>($object: UndefinedOnPartialDeep<T>): T {\n  return $object as T;\n}\n/**\n * Removes all `undefined` properties from an object when there are no mandatory keys with `undefined` values.\n *\n * @typeParam Type - The type of the object.\n * @param $arguments - The arguments to the function.\n * @returns The object with all `undefined` properties removed.\n */\nexport function removeUndefinedProperties<Type extends object>(\n  ...$arguments: RemoveUndefinedOverload<Type>\n): Type;\n/**\n * Removes all `undefined` properties from an object when there are mandatory keys with `undefined` values.\n *\n * @typeParam Type - The type of the object.\n * @typeParam KeysToKeep - The keys to keep.\n * @param $arguments - The arguments to the function.\n * @returns The object with all `undefined` properties removed.\n */\nexport function removeUndefinedProperties<Type extends object, const KeysToKeep extends readonly string[]>(\n  ...$arguments: RemoveUndefinedWithKeysOverload<Type, KeysToKeep>\n): Type;\n/**\n * Removes all `undefined` properties from an object.\n *\n * @typeParam Type - The type of the object.\n * @param $object - The object to remove `undefined` properties from.\n * @param keysToKeep - The keys to keep.\n * @returns The object with all `undefined` properties removed.\n */\nexport function removeUndefinedProperties<Type extends object>($object: Type, keysToKeep?: readonly string[]): Type {\n  for (const [key, value] of Object.entries($object) as [StringKeys<Type>, unknown][]) {\n    if (value === undefined && !keysToKeep?.includes(key)) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- We have no other way to delete the property.\n      delete $object[key];\n    }\n  }\n  return $object;\n}\n\n/**\n * Sets the value of a nested property in an object.\n *\n * @param params - The parameters for setting the nested property value.\n */\nexport function setNestedPropertyValue(params: SetNestedPropertyValueParams): void {\n  const {\n    $object,\n    path,\n    value\n  } = params;\n  const error = new Error(`Property path ${path} not found`);\n  let node: GenericObject | undefined = $object;\n  const keys = path.split(KEY_SEPARATOR);\n  for (const key of keys.slice(0, -1)) {\n    if (node === undefined) {\n      throw error;\n    }\n    node = node[key] as GenericObject | undefined;\n  }\n\n  const lastKey = ensureNonNullable(keys.at(-1));\n  if (node === undefined) {\n    throw error;\n  }\n\n  node[lastKey] = value;\n}\n\n/**\n * Converts a given value to a JSON string.\n *\n * @param value - The value to be converted to JSON. This can be of any type.\n * @param options - Options for customizing the JSON conversion process.\n * @returns The JSON string representation of the input value.\n */\nexport function toJson(value: unknown, options: Partial<ToJsonOptions> = {}): string {\n  return new ToJsonConverter(options).convert(value);\n}\n\nfunction applySubstitutions(params: ApplySubstitutionsParams): MaybeReturn<string> {\n  switch (params.key) {\n    case TokenSubstitutionKey.CircularReference: {\n      return params.substitutions.circularReference;\n    }\n    case TokenSubstitutionKey.Function: {\n      return ensureNonNullable(params.functionTexts[params.index], `Function with index ${String(params.index)} not found`);\n    }\n    case TokenSubstitutionKey.MaxDepthLimitReached: {\n      return params.substitutions.maxDepthLimitReached;\n    }\n    case TokenSubstitutionKey.MaxDepthLimitReachedArray: {\n      return `Array(${String(params.index)})`;\n    }\n    case TokenSubstitutionKey.ToJSONFailed: {\n      return params.substitutions.toJSONFailed;\n    }\n    case TokenSubstitutionKey.Undefined: {\n      return 'undefined';\n    }\n    /* v8 ignore start -- Exhaustive switch guard; default branch is unreachable. */\n    default: {\n      assertNever(params.key);\n    }\n      /* v8 ignore stop */\n  }\n}\n\nfunction assignWithNonEnumerablePropertiesImpl(target: object, ...sources: object[]): object {\n  for (const source of sources) {\n    const descriptors = Object.getOwnPropertyDescriptors(source);\n\n    for (const [key, descriptor] of Object.entries(descriptors)) {\n      try {\n        // Avoid redefining read-only properties (especially `prototype`)\n        if (\n          key === 'prototype'\n          || (Object.getOwnPropertyDescriptor(target, key)?.writable === false\n            && !Object.getOwnPropertyDescriptor(target, key)?.configurable)\n        ) {\n          continue;\n        }\n\n        Object.defineProperty(target, key, descriptor);\n      } catch {\n        // Silently ignore if defineProperty fails\n      }\n    }\n  }\n\n  const sourcePrototypes = sources\n    .map((source) => getPrototypeOf<object | undefined>(source))\n    .filter((prototype): prototype is object => !!prototype);\n\n  if (sourcePrototypes.length > 0) {\n    const targetPrototype = assignWithNonEnumerablePropertiesImpl({}, getPrototypeOf(target), ...sourcePrototypes);\n\n    try {\n      Object.setPrototypeOf(target, targetPrototype);\n    } catch {\n      // Silently ignore if setPrototypeOf fails\n    }\n  }\n\n  return target;\n}\n\n/*\n * The one place where the list's heterogeneity is bridged, and it needs a cast because the correlation that makes it\n * safe is a runtime one: `tryEntryEquality` calls the comparer only after `a instanceof entry.constructor` has held for\n * both operands, and no type can tie that `instanceof` to this entry's `T`. Confining the cast here buys the check the\n * list used to lack - the constructor and the comparer are inferred from ONE `T`, so a mismatched pair is a compile\n * error at the call site instead of being waved through by an `any`-typed entry array.\n */\nfunction createEqualityComparerEntry<T>(constructor: Constructor<T>, checkIsEqual: (a: T, b: T) => boolean): EqualityComparerEntry<unknown> {\n  return {\n    constructor,\n    equalityComparer: (a, b) => checkIsEqual(a as T, b as T)\n  };\n}\n\nfunction deepEqualTyped(a: unknown, b: unknown): boolean | undefined {\n  for (const entry of equalityComparerEntries) {\n    const result = tryEntryEquality({\n      a,\n      b,\n      entry\n    });\n    if (result !== undefined) {\n      return result;\n    }\n  }\n  return undefined;\n}\n\nfunction isDeepEqualArrayBuffer(a: ArrayBuffer, b: ArrayBuffer): boolean {\n  if (a.byteLength !== b.byteLength) {\n    return false;\n  }\n\n  const viewA = new Uint8Array(a);\n  const viewB = new Uint8Array(b);\n  return isDeepEqual(viewA, viewB);\n}\n\nfunction isDeepEqualDate(a: Date, b: Date): boolean {\n  return a.getTime() === b.getTime();\n}\n\nfunction isDeepEqualMap(a: Map<unknown, unknown>, b: Map<unknown, unknown>): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const [key, value] of a) {\n    if (!b.has(key) || !isDeepEqual(value, b.get(key))) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isDeepEqualRegExp(a: RegExp, b: RegExp): boolean {\n  return a.source === b.source && a.flags === b.flags;\n}\n\nfunction isDeepEqualSet(a: Set<unknown>, b: Set<unknown>): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const valueA of a) {\n    if (b.has(valueA)) {\n      continue;\n    }\n    let hasMatch = false;\n    for (const valueB of b) {\n      if (isDeepEqual(valueA, valueB)) {\n        hasMatch = true;\n        break;\n      }\n    }\n    if (!hasMatch) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction makeObjectTokenSubstitution(key: TokenSubstitutionKey): string {\n  return `{ \"[[${key}]]\": null }`;\n}\n\nfunction makePlaceholder(key: TokenSubstitutionKey, index?: number): string {\n  return `[[${PLACEHOLDER_KEY_PREFIX}${key}${index ? String(index) : ''}]]`;\n}\n\nfunction tryEntryEquality(params: TryEntryEqualityParams): boolean | undefined {\n  const {\n    a,\n    b,\n    entry\n  } = params;\n  return a instanceof entry.constructor && b instanceof entry.constructor ? entry.equalityComparer(a, b) : undefined;\n}\n"],
  "mappings": "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",
  "names": ["FunctionHandlingMode", "module"]
}
