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";
+ }
|
