first_commit

GTA_P_V2/node_modules/jest-leak-detector/build/index.d.mts

@@ -0,0 +1,16 @@
+//#region src/index.d.ts
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+declare class LeakDetector {
+  private _isReferenceBeingHeld;
+  private readonly _finalizationRegistry?;
+  constructor(value: unknown);
+  isLeaking(): Promise<boolean>;
+  private _runGarbageCollector;
+}
+//#endregion
+export { LeakDetector as default };

GTA_P_V2/node_modules/jest-leak-detector/build/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+declare class LeakDetector {
+  private _isReferenceBeingHeld;
+  private _shouldGenerateV8HeapSnapshot;
+  private readonly _finalizationRegistry?;
+  constructor(value: unknown, opt?: LeakDetectorOptions);
+  isLeaking(): Promise<boolean>;
+  private _runGarbageCollector;
+}
+export default LeakDetector;
+
+declare interface LeakDetectorOptions {
+  shouldGenerateV8HeapSnapshot: boolean;
+}
+
+export {};

GTA_P_V2/node_modules/jest-leak-detector/build/index.js

@@ -0,0 +1,123 @@
+/*!
+ * /**
+ *  * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *  *
+ *  * This source code is licensed under the MIT license found in the
+ *  * LICENSE file in the root directory of this source tree.
+ *  * /
+ */
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it uses a non-standard name for the exports (exports).
+(() => {
+var exports = __webpack_exports__;
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+function _util() {
+  const data = require("util");
+  _util = function () {
+    return data;
+  };
+  return data;
+}
+function _v() {
+  const data = require("v8");
+  _v = function () {
+    return data;
+  };
+  return data;
+}
+function _vm() {
+  const data = require("vm");
+  _vm = function () {
+    return data;
+  };
+  return data;
+}
+function _getType() {
+  const data = require("@jest/get-type");
+  _getType = function () {
+    return data;
+  };
+  return data;
+}
+function _prettyFormat() {
+  const data = require("pretty-format");
+  _prettyFormat = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference lib="es2021.WeakRef" />
+
+const tick = (0, _util().promisify)(setImmediate);
+class LeakDetector {
+  _isReferenceBeingHeld;
+  _shouldGenerateV8HeapSnapshot;
+  _finalizationRegistry;
+  constructor(value, opt) {
+    if ((0, _getType().isPrimitive)(value)) {
+      throw new TypeError(['Primitives cannot leak memory.', `You passed a ${typeof value}: <${(0, _prettyFormat().format)(value)}>`].join(' '));
+    }
+
+    // When `_finalizationRegistry` is GCed the callback we set will no longer be called,
+    this._finalizationRegistry = new FinalizationRegistry(() => {
+      this._isReferenceBeingHeld = false;
+    });
+    this._finalizationRegistry.register(value, undefined);
+    this._isReferenceBeingHeld = true;
+    this._shouldGenerateV8HeapSnapshot = opt?.shouldGenerateV8HeapSnapshot ?? true;
+
+    // Ensure value is not leaked by the closure created by the "weak" callback.
+    value = null;
+  }
+  async isLeaking() {
+    this._runGarbageCollector();
+
+    // wait some ticks to allow GC to run properly, see https://github.com/nodejs/node/issues/34636#issuecomment-669366235
+    for (let i = 0; i < 10; i++) {
+      await tick();
+    }
+    if (this._isReferenceBeingHeld) {
+      if (this._shouldGenerateV8HeapSnapshot) {
+        // Triggering a heap snapshot is more aggressive than just calling `global.gc()`,
+        // but it's also quite slow. Only do it if we still think we're leaking.
+        // See: https://github.com/nodejs/node/pull/48510#issuecomment-1719289759
+        (0, _v().getHeapSnapshot)();
+      }
+      for (let i = 0; i < 10; i++) {
+        await tick();
+      }
+    }
+    return this._isReferenceBeingHeld;
+  }
+  _runGarbageCollector() {
+    const isGarbageCollectorHidden = globalThis.gc == null;
+
+    // GC is usually hidden, so we have to expose it before running.
+    (0, _v().setFlagsFromString)('--expose-gc');
+    (0, _vm().runInNewContext)('gc')();
+
+    // The GC was not initially exposed, so let's hide it again.
+    if (isGarbageCollectorHidden) {
+      (0, _v().setFlagsFromString)('--no-expose-gc');
+    }
+  }
+}
+exports["default"] = LeakDetector;
+})();
+
+module.exports = __webpack_exports__;
+/******/ })()
+;

GTA_P_V2/node_modules/jest-leak-detector/build/index.mjs

@@ -0,0 +1,3 @@
+import cjsModule from './index.js';
+
+export default cjsModule.default;