:bug: patch modules

3 files changed, 644 insertions, 0 deletions

diff --git a/util/patches/ajv+8.6.2.patch b/util/patches/ajv+8.6.2.patch
new file mode 100644
index 00000000..e7556179
--- /dev/null
+++ b/util/patches/ajv+8.6.2.patch
@@ -0,0 +1,249 @@
+diff --git a/node_modules/ajv/dist/compile/jtd/parse.js b/node_modules/ajv/dist/compile/jtd/parse.js
+index 1eeb1be..7684121 100644
+--- a/node_modules/ajv/dist/compile/jtd/parse.js
++++ b/node_modules/ajv/dist/compile/jtd/parse.js
+@@ -239,6 +239,9 @@ function parseType(cxt) {
+             gen.if(fail, () => parsingError(cxt, codegen_1.str `invalid timestamp`));
+             break;
+         }
++		case "bigint":
++			parseBigInt(cxt);
++			break
+         case "float32":
+         case "float64":
+             parseNumber(cxt);
+@@ -284,6 +287,15 @@ function parseNumber(cxt, maxDigits) {
+     skipWhitespace(cxt);
+     gen.if(codegen_1._ `"-0123456789".indexOf(${jsonSlice(1)}) < 0`, () => jsonSyntaxError(cxt), () => parseWith(cxt, parseJson_1.parseJsonNumber, maxDigits));
+ }
++function parseBigInt(cxt, maxDigits) {
++  const {gen} = cxt
++  skipWhitespace(cxt)
++  gen.if(
++    _`"-0123456789".indexOf(${jsonSlice(1)}) < 0`,
++    () => jsonSyntaxError(cxt),
++    () => parseWith(cxt, parseJson_1.parseJsonBigInt, maxDigits)
++  )
++}
+ function parseBooleanToken(bool, fail) {
+     return (cxt) => {
+         const { gen, data } = cxt;
+diff --git a/node_modules/ajv/dist/compile/rules.js b/node_modules/ajv/dist/compile/rules.js
+index 82a591f..1ebd8fe 100644
+--- a/node_modules/ajv/dist/compile/rules.js
++++ b/node_modules/ajv/dist/compile/rules.js
+@@ -1,7 +1,7 @@
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.getRules = exports.isJSONType = void 0;
+-const _jsonTypes = ["string", "number", "integer", "boolean", "null", "object", "array"];
++const _jsonTypes = ["string", "number", "integer", "boolean", "null", "object", "array","bigint"];
+ const jsonTypes = new Set(_jsonTypes);
+ function isJSONType(x) {
+     return typeof x == "string" && jsonTypes.has(x);
+@@ -13,10 +13,11 @@ function getRules() {
+         string: { type: "string", rules: [] },
+         array: { type: "array", rules: [] },
+         object: { type: "object", rules: [] },
++		bigint: {type: "bigint", rules: []}
+     };
+     return {
+-        types: { ...groups, integer: true, boolean: true, null: true },
+-        rules: [{ rules: [] }, groups.number, groups.string, groups.array, groups.object],
++        types: { ...groups, integer: true, boolean: true, null: true, bigint: true },
++        rules: [{ rules: [] }, groups.number, groups.string, groups.array, groups.object, groups.bigint],
+         post: { rules: [] },
+         all: {},
+         keywords: {},
+diff --git a/node_modules/ajv/dist/compile/validate/dataType.js b/node_modules/ajv/dist/compile/validate/dataType.js
+index 6319e76..8b50b4c 100644
+--- a/node_modules/ajv/dist/compile/validate/dataType.js
++++ b/node_modules/ajv/dist/compile/validate/dataType.js
+@@ -52,7 +52,7 @@ function coerceAndCheckDataType(it, types) {
+     return checkTypes;
+ }
+ exports.coerceAndCheckDataType = coerceAndCheckDataType;
+-const COERCIBLE = new Set(["string", "number", "integer", "boolean", "null"]);
++const COERCIBLE = new Set(["string", "number", "integer", "boolean", "null","bigint"]);
+ function coerceToTypes(types, coerceTypes) {
+     return coerceTypes
+         ? types.filter((t) => COERCIBLE.has(t) || (coerceTypes === "array" && t === "array"))
+@@ -83,6 +83,14 @@ function coerceData(it, types, coerceTo) {
+     });
+     function coerceSpecificType(t) {
+         switch (t) {
++			case "bigint":
++				gen
++				.elseIf(
++					codegen_1._`${dataType} == "boolean" || ${data} === null
++					|| (${dataType} == "string" && ${data} && ${data} == BigInt(${data}))`
++				)
++				.assign(coerced, codegen_1._`BigInt(${data})`)
++				return
+             case "string":
+                 gen
+                     .elseIf(codegen_1._ `${dataType} == "number" || ${dataType} == "boolean"`)
+@@ -143,6 +151,9 @@ function checkDataType(dataType, data, strictNums, correct = DataType.Correct) {
+         case "number":
+             cond = numCond();
+             break;
++		 case "bigint":
++			cond = codegen_1._`typeof ${data} == "bigint" && isFinite(${data})`
++			break
+         default:
+             return codegen_1._ `typeof ${data} ${EQ} ${dataType}`;
+     }
+diff --git a/node_modules/ajv/dist/refs/json-schema-2019-09/meta/validation.json b/node_modules/ajv/dist/refs/json-schema-2019-09/meta/validation.json
+index 7027a12..25679c8 100644
+--- a/node_modules/ajv/dist/refs/json-schema-2019-09/meta/validation.json
++++ b/node_modules/ajv/dist/refs/json-schema-2019-09/meta/validation.json
+@@ -78,7 +78,7 @@
+       "default": 0
+     },
+     "simpleTypes": {
+-      "enum": ["array", "boolean", "integer", "null", "number", "object", "string"]
++      "enum": ["array", "boolean", "integer", "null", "number", "object", "string","bigint"]
+     },
+     "stringArray": {
+       "type": "array",
+diff --git a/node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json b/node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json
+index e0ae13d..57c9036 100644
+--- a/node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json
++++ b/node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json
+@@ -78,7 +78,7 @@
+       "default": 0
+     },
+     "simpleTypes": {
+-      "enum": ["array", "boolean", "integer", "null", "number", "object", "string"]
++      "enum": ["array", "boolean", "integer", "null", "number", "object", "string","bigint"]
+     },
+     "stringArray": {
+       "type": "array",
+diff --git a/node_modules/ajv/dist/refs/json-schema-draft-06.json b/node_modules/ajv/dist/refs/json-schema-draft-06.json
+index 5410064..774435b 100644
+--- a/node_modules/ajv/dist/refs/json-schema-draft-06.json
++++ b/node_modules/ajv/dist/refs/json-schema-draft-06.json
+@@ -16,7 +16,7 @@
+       "allOf": [{"$ref": "#/definitions/nonNegativeInteger"}, {"default": 0}]
+     },
+     "simpleTypes": {
+-      "enum": ["array", "boolean", "integer", "null", "number", "object", "string"]
++      "enum": ["array", "boolean", "integer", "null", "number", "object", "string","bigint"]
+     },
+     "stringArray": {
+       "type": "array",
+diff --git a/node_modules/ajv/dist/refs/json-schema-draft-07.json b/node_modules/ajv/dist/refs/json-schema-draft-07.json
+index 6a74851..fc6dd7d 100644
+--- a/node_modules/ajv/dist/refs/json-schema-draft-07.json
++++ b/node_modules/ajv/dist/refs/json-schema-draft-07.json
+@@ -16,7 +16,7 @@
+       "allOf": [{"$ref": "#/definitions/nonNegativeInteger"}, {"default": 0}]
+     },
+     "simpleTypes": {
+-      "enum": ["array", "boolean", "integer", "null", "number", "object", "string"]
++      "enum": ["array", "boolean", "integer", "null", "number", "object", "string","bigint"]
+     },
+     "stringArray": {
+       "type": "array",
+diff --git a/node_modules/ajv/dist/refs/jtd-schema.js b/node_modules/ajv/dist/refs/jtd-schema.js
+index 1ee940a..1148887 100644
+--- a/node_modules/ajv/dist/refs/jtd-schema.js
++++ b/node_modules/ajv/dist/refs/jtd-schema.js
+@@ -38,6 +38,7 @@ const typeForm = (root) => ({
+                 "uint16",
+                 "int32",
+                 "uint32",
++                "bigint",
+             ],
+         },
+     },
+diff --git a/node_modules/ajv/dist/runtime/parseJson.js b/node_modules/ajv/dist/runtime/parseJson.js
+index 2576a6e..e7447b1 100644
+--- a/node_modules/ajv/dist/runtime/parseJson.js
++++ b/node_modules/ajv/dist/runtime/parseJson.js
+@@ -97,6 +97,71 @@ exports.parseJsonNumber = parseJsonNumber;
+ parseJsonNumber.message = undefined;
+ parseJsonNumber.position = 0;
+ parseJsonNumber.code = 'require("ajv/dist/runtime/parseJson").parseJsonNumber';
++
++function parseJsonBigInt(s, pos, maxDigits) {
++    let numStr = "";
++    let c;
++    parseJsonBigInt.message = undefined;
++    if (s[pos] === "-") {
++        numStr += "-";
++        pos++;
++    }
++    if (s[pos] === "0") {
++        numStr += "0";
++        pos++;
++    }
++    else {
++        if (!parseDigits(maxDigits)) {
++            errorMessage();
++            return undefined;
++        }
++    }
++    if (maxDigits) {
++        parseJsonBigInt.position = pos;
++        return BigInt(numStr);
++    }
++    if (s[pos] === ".") {
++        numStr += ".";
++        pos++;
++        if (!parseDigits()) {
++            errorMessage();
++            return undefined;
++        }
++    }
++    if (((c = s[pos]), c === "e" || c === "E")) {
++        numStr += "e";
++        pos++;
++        if (((c = s[pos]), c === "+" || c === "-")) {
++            numStr += c;
++            pos++;
++        }
++        if (!parseDigits()) {
++            errorMessage();
++            return undefined;
++        }
++    }
++    parseJsonBigInt.position = pos;
++    return BigInt(numStr);
++    function parseDigits(maxLen) {
++        let digit = false;
++        while (((c = s[pos]), c >= "0" && c <= "9" && (maxLen === undefined || maxLen-- > 0))) {
++            digit = true;
++            numStr += c;
++            pos++;
++        }
++        return digit;
++    }
++    function errorMessage() {
++        parseJsonBigInt.position = pos;
++        parseJsonBigInt.message = pos < s.length ? `unexpected token ${s[pos]}` : "unexpected end";
++    }
++}
++exports.parseJsonBigInt = parseJsonBigInt;
++parseJsonBigInt.message = undefined;
++parseJsonBigInt.position = 0;
++parseJsonBigInt.code = 'require("ajv/dist/runtime/parseJson").parseJsonBigInt';
++
++
+ const escapedChars = {
+     b: "\b",
+     f: "\f",
+diff --git a/node_modules/ajv/dist/vocabularies/jtd/type.js b/node_modules/ajv/dist/vocabularies/jtd/type.js
+index 428bddb..fbc3070 100644
+--- a/node_modules/ajv/dist/vocabularies/jtd/type.js
++++ b/node_modules/ajv/dist/vocabularies/jtd/type.js
+@@ -45,6 +45,9 @@ const def = {
+                 cond = timestampCode(cxt);
+                 break;
+             }
++			case "bigint":
++				cond = codegen_1._`typeof ${data} == "bigint" || typeof ${data} == "string"`
++				break
+             case "float32":
+             case "float64":
+                 cond = codegen_1._ `typeof ${data} == "number"`;
diff --git a/util/patches/test-performance+1.1.3.patch b/util/patches/test-performance+1.1.3.patch
new file mode 100644
index 00000000..23b4900b
--- /dev/null
+++ b/util/patches/test-performance+1.1.3.patch
@@ -0,0 +1,381 @@
+diff --git a/node_modules/test-performance/cjs/index.js b/node_modules/test-performance/cjs/index.js
+index 65d5904..04638a1 100644
+--- a/node_modules/test-performance/cjs/index.js
++++ b/node_modules/test-performance/cjs/index.js
+@@ -1,4 +1,4 @@
+-'use strict';
++"use strict";
+ 
+ /*! *****************************************************************************
+ Copyright (c) Microsoft Corporation.
+@@ -15,50 +15,139 @@ OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ PERFORMANCE OF THIS SOFTWARE.
+ ***************************************************************************** */
+ 
++const { performance } = require("perf_hooks");
++
+ function __awaiter(thisArg, _arguments, P, generator) {
+-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+-    return new (P || (P = Promise))(function (resolve, reject) {
+-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+-        step((generator = generator.apply(thisArg, _arguments || [])).next());
+-    });
++	function adopt(value) {
++		return value instanceof P
++			? value
++			: new P(function (resolve) {
++					resolve(value);
++			  });
++	}
++	return new (P || (P = Promise))(function (resolve, reject) {
++		function fulfilled(value) {
++			try {
++				step(generator.next(value));
++			} catch (e) {
++				reject(e);
++			}
++		}
++		function rejected(value) {
++			try {
++				step(generator["throw"](value));
++			} catch (e) {
++				reject(e);
++			}
++		}
++		function step(result) {
++			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
++		}
++		step((generator = generator.apply(thisArg, _arguments || [])).next());
++	});
+ }
+ 
+ function __generator(thisArg, body) {
+-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+-    function verb(n) { return function (v) { return step([n, v]); }; }
+-    function step(op) {
+-        if (f) throw new TypeError("Generator is already executing.");
+-        while (_) try {
+-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+-            if (y = 0, t) op = [op[0] & 2, t.value];
+-            switch (op[0]) {
+-                case 0: case 1: t = op; break;
+-                case 4: _.label++; return { value: op[1], done: false };
+-                case 5: _.label++; y = op[1]; op = [0]; continue;
+-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+-                default:
+-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+-                    if (t[2]) _.ops.pop();
+-                    _.trys.pop(); continue;
+-            }
+-            op = body.call(thisArg, _);
+-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+-    }
++	var _ = {
++			label: 0,
++			sent: function () {
++				if (t[0] & 1) throw t[1];
++				return t[1];
++			},
++			trys: [],
++			ops: [],
++		},
++		f,
++		y,
++		t,
++		g;
++	return (
++		(g = { next: verb(0), throw: verb(1), return: verb(2) }),
++		typeof Symbol === "function" &&
++			(g[Symbol.iterator] = function () {
++				return this;
++			}),
++		g
++	);
++	function verb(n) {
++		return function (v) {
++			return step([n, v]);
++		};
++	}
++	function step(op) {
++		if (f) throw new TypeError("Generator is already executing.");
++		while (_)
++			try {
++				if (
++					((f = 1),
++					y &&
++						(t =
++							op[0] & 2
++								? y["return"]
++								: op[0]
++								? y["throw"] || ((t = y["return"]) && t.call(y), 0)
++								: y.next) &&
++						!(t = t.call(y, op[1])).done)
++				)
++					return t;
++				if (((y = 0), t)) op = [op[0] & 2, t.value];
++				switch (op[0]) {
++					case 0:
++					case 1:
++						t = op;
++						break;
++					case 4:
++						_.label++;
++						return { value: op[1], done: false };
++					case 5:
++						_.label++;
++						y = op[1];
++						op = [0];
++						continue;
++					case 7:
++						op = _.ops.pop();
++						_.trys.pop();
++						continue;
++					default:
++						if (!((t = _.trys), (t = t.length > 0 && t[t.length - 1])) && (op[0] === 6 || op[0] === 2)) {
++							_ = 0;
++							continue;
++						}
++						if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
++							_.label = op[1];
++							break;
++						}
++						if (op[0] === 6 && _.label < t[1]) {
++							_.label = t[1];
++							t = op;
++							break;
++						}
++						if (t && _.label < t[2]) {
++							_.label = t[2];
++							_.ops.push(op);
++							break;
++						}
++						if (t[2]) _.ops.pop();
++						_.trys.pop();
++						continue;
++				}
++				op = body.call(thisArg, _);
++			} catch (e) {
++				op = [6, e];
++				y = 0;
++			} finally {
++				f = t = 0;
++			}
++		if (op[0] & 5) throw op[1];
++		return { value: op[0] ? op[1] : void 0, done: true };
++	}
+ }
+ 
+ var baselineFunctions = {
+-    standard: {
+-        expectedMsRunTime: 12,
+-        func: function (dummyParam) {
+-        },
+-    },
++	standard: {
++		expectedMsRunTime: 12,
++		func: function (dummyParam) {},
++	},
+ };
+ 
+ /**
+@@ -66,28 +155,28 @@ var baselineFunctions = {
+  * to a baseline.
+  */
+ function calculateExpectedPerformance(baselineExpected, baselineActual, target) {
+-    var performanceRatio = baselineActual / baselineExpected;
+-    return target / performanceRatio;
++	var performanceRatio = baselineActual / baselineExpected;
++	return target / performanceRatio;
+ }
+ 
+ /**
+  * This runs a single performance test of a function
+  */
+ function perfTest(func) {
+-    return __awaiter(this, void 0, void 0, function () {
+-        var start, end;
+-        return __generator(this, function (_a) {
+-            switch (_a.label) {
+-                case 0:
+-                    start = performance.now();
+-                    return [4 /*yield*/, func()];
+-                case 1:
+-                    _a.sent();
+-                    end = performance.now();
+-                    return [2 /*return*/, end - start];
+-            }
+-        });
+-    });
++	return __awaiter(this, void 0, void 0, function () {
++		var start, end;
++		return __generator(this, function (_a) {
++			switch (_a.label) {
++				case 0:
++					start = performance.now();
++					return [4 /*yield*/, func()];
++				case 1:
++					_a.sent();
++					end = performance.now();
++					return [2 /*return*/, end - start];
++			}
++		});
++	});
+ }
+ 
+ var NUMBER_OF_TESTS = 10000;
+@@ -96,22 +185,31 @@ var NUMBER_OF_TESTS = 10000;
+  * the average in milliseconds.
+  */
+ function getScore(func) {
+-    return __awaiter(this, void 0, void 0, function () {
+-        var tests, results;
+-        var _this = this;
+-        return __generator(this, function (_a) {
+-            switch (_a.label) {
+-                case 0:
+-                    tests = new Array(NUMBER_OF_TESTS).fill(undefined).map(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+-                        return [2 /*return*/, perfTest(func)];
+-                    }); }); });
+-                    return [4 /*yield*/, Promise.all(tests)];
+-                case 1:
+-                    results = _a.sent();
+-                    return [2 /*return*/, results.reduce(function (acc, val) { return acc + val; }, 0) / NUMBER_OF_TESTS];
+-            }
+-        });
+-    });
++	return __awaiter(this, void 0, void 0, function () {
++		var tests, results;
++		var _this = this;
++		return __generator(this, function (_a) {
++			switch (_a.label) {
++				case 0:
++					tests = new Array(NUMBER_OF_TESTS).fill(undefined).map(function () {
++						return __awaiter(_this, void 0, void 0, function () {
++							return __generator(this, function (_a) {
++								return [2 /*return*/, perfTest(func)];
++							});
++						});
++					});
++					return [4 /*yield*/, Promise.all(tests)];
++				case 1:
++					results = _a.sent();
++					return [
++						2 /*return*/,
++						results.reduce(function (acc, val) {
++							return acc + val;
++						}, 0) / NUMBER_OF_TESTS,
++					];
++			}
++		});
++	});
+ }
+ 
+ /**
+@@ -119,31 +217,38 @@ function getScore(func) {
+  * known baseline function.
+  */
+ function runTests(baselineFunc, targetFunc) {
+-    return __awaiter(this, void 0, void 0, function () {
+-        var initialBaselineScore, initialTargetScore, midwayBaselineScore, endTargetScore, endBaselineScore, totalBaselineScore, totalTargetScore;
+-        return __generator(this, function (_a) {
+-            switch (_a.label) {
+-                case 0: return [4 /*yield*/, getScore(baselineFunc)];
+-                case 1:
+-                    initialBaselineScore = _a.sent();
+-                    return [4 /*yield*/, getScore(targetFunc)];
+-                case 2:
+-                    initialTargetScore = _a.sent();
+-                    return [4 /*yield*/, getScore(baselineFunc)];
+-                case 3:
+-                    midwayBaselineScore = _a.sent();
+-                    return [4 /*yield*/, getScore(targetFunc)];
+-                case 4:
+-                    endTargetScore = _a.sent();
+-                    return [4 /*yield*/, getScore(baselineFunc)];
+-                case 5:
+-                    endBaselineScore = _a.sent();
+-                    totalBaselineScore = (initialBaselineScore + midwayBaselineScore + endBaselineScore) / 3;
+-                    totalTargetScore = (initialTargetScore + endTargetScore) / 2;
+-                    return [2 /*return*/, [totalBaselineScore, totalTargetScore]];
+-            }
+-        });
+-    });
++	return __awaiter(this, void 0, void 0, function () {
++		var initialBaselineScore,
++			initialTargetScore,
++			midwayBaselineScore,
++			endTargetScore,
++			endBaselineScore,
++			totalBaselineScore,
++			totalTargetScore;
++		return __generator(this, function (_a) {
++			switch (_a.label) {
++				case 0:
++					return [4 /*yield*/, getScore(baselineFunc)];
++				case 1:
++					initialBaselineScore = _a.sent();
++					return [4 /*yield*/, getScore(targetFunc)];
++				case 2:
++					initialTargetScore = _a.sent();
++					return [4 /*yield*/, getScore(baselineFunc)];
++				case 3:
++					midwayBaselineScore = _a.sent();
++					return [4 /*yield*/, getScore(targetFunc)];
++				case 4:
++					endTargetScore = _a.sent();
++					return [4 /*yield*/, getScore(baselineFunc)];
++				case 5:
++					endBaselineScore = _a.sent();
++					totalBaselineScore = (initialBaselineScore + midwayBaselineScore + endBaselineScore) / 3;
++					totalTargetScore = (initialTargetScore + endTargetScore) / 2;
++					return [2 /*return*/, [totalBaselineScore, totalTargetScore]];
++			}
++		});
++	});
+ }
+ 
+ /**
+@@ -152,20 +257,22 @@ function runTests(baselineFunc, targetFunc) {
+  */
+ var BASELINE_FUNCTION = baselineFunctions.standard;
+ function getPerformanceScore(func) {
+-    return __awaiter(this, void 0, void 0, function () {
+-        var _a, baseline, target;
+-        return __generator(this, function (_b) {
+-            switch (_b.label) {
+-                case 0:
+-                    if (typeof func !== 'function')
+-                        throw new Error(func + " is not a function");
+-                    return [4 /*yield*/, runTests(BASELINE_FUNCTION.func, func)];
+-                case 1:
+-                    _a = _b.sent(), baseline = _a[0], target = _a[1];
+-                    return [2 /*return*/, calculateExpectedPerformance(BASELINE_FUNCTION.expectedMsRunTime, baseline, target)];
+-            }
+-        });
+-    });
++	return __awaiter(this, void 0, void 0, function () {
++		var _a, baseline, target;
++		return __generator(this, function (_b) {
++			switch (_b.label) {
++				case 0:
++					if (typeof func !== "function") throw new Error(func + " is not a function");
++					return [4 /*yield*/, runTests(BASELINE_FUNCTION.func, func)];
++				case 1:
++					(_a = _b.sent()), (baseline = _a[0]), (target = _a[1]);
++					return [
++						2 /*return*/,
++						calculateExpectedPerformance(BASELINE_FUNCTION.expectedMsRunTime, baseline, target),
++					];
++			}
++		});
++	});
+ }
+ 
+ module.exports = getPerformanceScore;
diff --git a/util/patches/typescript-json-schema+0.50.1.patch b/util/patches/typescript-json-schema+0.50.1.patch
new file mode 100644
index 00000000..a0d479de
--- /dev/null
+++ b/util/patches/typescript-json-schema+0.50.1.patch
@@ -0,0 +1,14 @@
+diff --git a/node_modules/typescript-json-schema/dist/typescript-json-schema.js b/node_modules/typescript-json-schema/dist/typescript-json-schema.js
+index 47e1598..8397b9d 100644
+--- a/node_modules/typescript-json-schema/dist/typescript-json-schema.js
++++ b/node_modules/typescript-json-schema/dist/typescript-json-schema.js
+@@ -432,6 +432,9 @@ var JsonSchemaGenerator = (function () {
+             else if (flags & ts.TypeFlags.Boolean) {
+                 definition.type = "boolean";
+             }
++            else if (flags & ts.TypeFlags.BigInt) {
++                definition.type = "bigint";
++            }
+             else if (flags & ts.TypeFlags.Null) {
+                 definition.type = "null";
+             }