modelfusion 0.91.0 → 0.92.1

package/util/AsyncQueue.test.cjs

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
 const delay_js_1 = require("./delay.cjs");
 const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
-(0, vitest_1.test)("receive values in order for single iterator created before pushing", async () => {
+it("should receive values in order for single iterator created before pushing", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     const receivedValues = [];
     const receiveValuesPromise = (async () => {
@@ -16,9 +15,9 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
     asyncQueue.push(3);
     asyncQueue.close();
     await receiveValuesPromise;
-    (0, vitest_1.expect)(receivedValues).toEqual([1, 2, 3]);
+    expect(receivedValues).toEqual([1, 2, 3]);
 });
-(0, vitest_1.test)("receive values in order for single iterator created after closing", async () => {
+it("should receive values in order for single iterator created after closing", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     asyncQueue.push(1);
     asyncQueue.push(2);
@@ -31,9 +30,9 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
         }
     })();
     await receiveValuesPromise;
-    (0, vitest_1.expect)(receivedValues).toEqual([1, 2, 3]);
+    expect(receivedValues).toEqual([1, 2, 3]);
 });
-(0, vitest_1.test)("handle delayed pushing", async () => {
+it("should handle delayed pushing", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     setTimeout(() => {
         asyncQueue.push(1);
@@ -44,12 +43,12 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
     for await (const value of asyncQueue) {
         receivedValues.push(value);
     }
-    (0, vitest_1.expect)(receivedValues).toEqual([1, 2]);
+    expect(receivedValues).toEqual([1, 2]);
 });
-(0, vitest_1.test)("error handling in consumer", async () => {
+it("should error handling in consumer", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     asyncQueue.push(1);
-    await (0, vitest_1.expect)((async () => {
+    await expect((async () => {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         for await (const _value of asyncQueue) {
             throw new Error("Consumer error");
@@ -62,23 +61,23 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
     for await (const value of asyncQueue) {
         receivedValues.push(value);
     }
-    (0, vitest_1.expect)(receivedValues).toEqual([1, 2]);
+    expect(receivedValues).toEqual([1, 2]);
 });
-(0, vitest_1.test)("behavior on empty queue closing", async () => {
+it("should behavior on empty queue closing", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     asyncQueue.close();
     const receivedValues = [];
     for await (const value of asyncQueue) {
         receivedValues.push(value);
     }
-    (0, vitest_1.expect)(receivedValues).toEqual([]);
+    expect(receivedValues).toEqual([]);
 });
-(0, vitest_1.test)("multiple closings", async () => {
+it("should multiple closings", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     asyncQueue.close();
-    (0, vitest_1.expect)(() => asyncQueue.close()).not.toThrow();
+    expect(() => asyncQueue.close()).not.toThrow();
 });
-(0, vitest_1.test)("receive all values in multiple independent consumers", async () => {
+it("should receive all values in multiple independent consumers", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     const consumerPromises = [1, 2].map(async () => {
         const receivedValues = [];
@@ -97,10 +96,10 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
     asyncQueue.close();
     const allReceivedValues = await Promise.all(consumerPromises);
     allReceivedValues.forEach((receivedValues) => {
-        (0, vitest_1.expect)(receivedValues).toEqual([1, 2, 3]);
+        expect(receivedValues).toEqual([1, 2, 3]);
     });
 });
-(0, vitest_1.test)("each consumer receives all pushed values under varying conditions", async () => {
+it("should each consumer receives all pushed values under varying conditions", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     // Start the first consumer, which will await values.
     const receivedValues1 = [];
@@ -128,11 +127,11 @@ const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
     asyncQueue.close();
     await Promise.all([consumer1, consumer2]);
     // Both consumers should have received all values, even if they started at different times.
-    (0, vitest_1.expect)(receivedValues1).toEqual([1, 2, 3]);
-    (0, vitest_1.expect)(receivedValues2).toEqual([1, 2, 3]); // This will likely fail because consumer2 started late.
+    expect(receivedValues1).toEqual([1, 2, 3]);
+    expect(receivedValues2).toEqual([1, 2, 3]); // This will likely fail because consumer2 started late.
 });
-(0, vitest_1.test)("throw error when pushing to a closed queue", async () => {
+it("should throw error when pushing to a closed queue", async () => {
     const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
     asyncQueue.close();
-    (0, vitest_1.expect)(() => asyncQueue.push(1)).toThrowError("Cannot push value to closed queue.");
+    expect(() => asyncQueue.push(1)).toThrowError("Cannot push value to closed queue.");
 });

package/util/AsyncQueue.test.js

@@ -1,7 +1,6 @@
-import { expect, test } from "vitest";
 import { delay } from "./delay.js";
 import { AsyncQueue } from "./AsyncQueue.js";
-test("receive values in order for single iterator created before pushing", async () => {
+it("should receive values in order for single iterator created before pushing", async () => {
     const asyncQueue = new AsyncQueue();
     const receivedValues = [];
     const receiveValuesPromise = (async () => {
@@ -16,7 +15,7 @@ test("receive values in order for single iterator created before pushing", async
     await receiveValuesPromise;
     expect(receivedValues).toEqual([1, 2, 3]);
 });
-test("receive values in order for single iterator created after closing", async () => {
+it("should receive values in order for single iterator created after closing", async () => {
     const asyncQueue = new AsyncQueue();
     asyncQueue.push(1);
     asyncQueue.push(2);
@@ -31,7 +30,7 @@ test("receive values in order for single iterator created after closing", async
     await receiveValuesPromise;
     expect(receivedValues).toEqual([1, 2, 3]);
 });
-test("handle delayed pushing", async () => {
+it("should handle delayed pushing", async () => {
     const asyncQueue = new AsyncQueue();
     setTimeout(() => {
         asyncQueue.push(1);
@@ -44,7 +43,7 @@ test("handle delayed pushing", async () => {
     }
     expect(receivedValues).toEqual([1, 2]);
 });
-test("error handling in consumer", async () => {
+it("should error handling in consumer", async () => {
     const asyncQueue = new AsyncQueue();
     asyncQueue.push(1);
     await expect((async () => {
@@ -62,7 +61,7 @@ test("error handling in consumer", async () => {
     }
     expect(receivedValues).toEqual([1, 2]);
 });
-test("behavior on empty queue closing", async () => {
+it("should behavior on empty queue closing", async () => {
     const asyncQueue = new AsyncQueue();
     asyncQueue.close();
     const receivedValues = [];
@@ -71,12 +70,12 @@ test("behavior on empty queue closing", async () => {
     }
     expect(receivedValues).toEqual([]);
 });
-test("multiple closings", async () => {
+it("should multiple closings", async () => {
     const asyncQueue = new AsyncQueue();
     asyncQueue.close();
     expect(() => asyncQueue.close()).not.toThrow();
 });
-test("receive all values in multiple independent consumers", async () => {
+it("should receive all values in multiple independent consumers", async () => {
     const asyncQueue = new AsyncQueue();
     const consumerPromises = [1, 2].map(async () => {
         const receivedValues = [];
@@ -98,7 +97,7 @@ test("receive all values in multiple independent consumers", async () => {
         expect(receivedValues).toEqual([1, 2, 3]);
     });
 });
-test("each consumer receives all pushed values under varying conditions", async () => {
+it("should each consumer receives all pushed values under varying conditions", async () => {
     const asyncQueue = new AsyncQueue();
     // Start the first consumer, which will await values.
     const receivedValues1 = [];
@@ -129,7 +128,7 @@ test("each consumer receives all pushed values under varying conditions", async
     expect(receivedValues1).toEqual([1, 2, 3]);
     expect(receivedValues2).toEqual([1, 2, 3]); // This will likely fail because consumer2 started late.
 });
-test("throw error when pushing to a closed queue", async () => {
+it("should throw error when pushing to a closed queue", async () => {
     const asyncQueue = new AsyncQueue();
     asyncQueue.close();
     expect(() => asyncQueue.push(1)).toThrowError("Cannot push value to closed queue.");

package/util/isDeepEqualData.test.cjs

@@ -4,9 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_assert_1 = __importDefault(require("node:assert"));
-const vitest_1 = require("vitest");
 const isDeepEqualData_js_1 = require("./isDeepEqualData.cjs");
-(0, vitest_1.test)("checks if two primitives are equal", async () => {
+it("should check if two primitives are equal", async () => {
     let x = 1;
     let y = 1;
     let result = (0, isDeepEqualData_js_1.isDeepEqualData)(x, y);
@@ -16,48 +15,48 @@ const isDeepEqualData_js_1 = require("./isDeepEqualData.cjs");
     result = (0, isDeepEqualData_js_1.isDeepEqualData)(x, y);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("returns false for different types", async () => {
+it("should return false for different types", async () => {
     const obj = { a: 1 };
     const num = 1;
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj, num);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("returns false for null values compared with objects", async () => {
+it("should return false for null values compared with objects", async () => {
     const obj = { a: 1 };
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj, null);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("identifies two equal objects", async () => {
+it("should identify two equal objects", async () => {
     const obj1 = { a: 1, b: 2 };
     const obj2 = { a: 1, b: 2 };
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj1, obj2);
     node_assert_1.default.equal(result, true);
 });
-(0, vitest_1.test)("identifies two objects with different values", async () => {
+it("should identify two objects with different values", async () => {
     const obj1 = { a: 1, b: 2 };
     const obj2 = { a: 1, b: 3 };
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj1, obj2);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("identifies two objects with different number of keys", async () => {
+it("should identify two objects with different number of keys", async () => {
     const obj1 = { a: 1, b: 2 };
     const obj2 = { a: 1, b: 2, c: 3 };
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj1, obj2);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("handles nested objects", async () => {
+it("should handle nested objects", async () => {
     const obj1 = { a: { c: 1 }, b: 2 };
     const obj2 = { a: { c: 1 }, b: 2 };
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj1, obj2);
     node_assert_1.default.equal(result, true);
 });
-(0, vitest_1.test)("detects inequality in nested objects", async () => {
+it("should detect inequality in nested objects", async () => {
     const obj1 = { a: { c: 1 }, b: 2 };
     const obj2 = { a: { c: 2 }, b: 2 };
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj1, obj2);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("compares arrays correctly", async () => {
+it("should compare arrays correctly", async () => {
     const arr1 = [1, 2, 3];
     const arr2 = [1, 2, 3];
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(arr1, arr2);
@@ -67,18 +66,18 @@ const isDeepEqualData_js_1 = require("./isDeepEqualData.cjs");
     const result2 = (0, isDeepEqualData_js_1.isDeepEqualData)(arr3, arr4);
     node_assert_1.default.equal(result2, false);
 });
-(0, vitest_1.test)("returns false for null comparison with object", () => {
+it("should return false for null comparison with object", () => {
     const obj = { a: 1 };
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj, null);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("distinguishes between array and object with same enumerable properties", () => {
+it("should distinguish between array and object with same enumerable properties", () => {
     const obj = { 0: "one", 1: "two", length: 2 };
     const arr = ["one", "two"];
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj, arr);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("returns false when comparing objects with different prototypes", () => {
+it("should return false when comparing objects with different prototypes", () => {
     const obj1 = Object.create({ a: 1 });
     const obj2 = Object.create(null);
     obj1.b = 2;
@@ -86,14 +85,14 @@ const isDeepEqualData_js_1 = require("./isDeepEqualData.cjs");
     const result = (0, isDeepEqualData_js_1.isDeepEqualData)(obj1, obj2);
     node_assert_1.default.equal(result, false);
 });
-(0, vitest_1.test)("handles date object comparisons correctly", () => {
+it("should handle date object comparisons correctly", () => {
     const date1 = new Date(2000, 0, 1);
     const date2 = new Date(2000, 0, 1);
     const date3 = new Date(2000, 0, 2);
     node_assert_1.default.equal((0, isDeepEqualData_js_1.isDeepEqualData)(date1, date2), true);
     node_assert_1.default.equal((0, isDeepEqualData_js_1.isDeepEqualData)(date1, date3), false);
 });
-(0, vitest_1.test)("handles function comparisons", () => {
+it("should handle function comparisons", () => {
     const func1 = () => {
         console.log("hello");
     };

package/util/isDeepEqualData.test.js

@@ -1,7 +1,6 @@
 import assert from "node:assert";
-import { test } from "vitest";
 import { isDeepEqualData } from "./isDeepEqualData.js";
-test("checks if two primitives are equal", async () => {
+it("should check if two primitives are equal", async () => {
     let x = 1;
     let y = 1;
     let result = isDeepEqualData(x, y);
@@ -11,48 +10,48 @@ test("checks if two primitives are equal", async () => {
     result = isDeepEqualData(x, y);
     assert.equal(result, false);
 });
-test("returns false for different types", async () => {
+it("should return false for different types", async () => {
     const obj = { a: 1 };
     const num = 1;
     const result = isDeepEqualData(obj, num);
     assert.equal(result, false);
 });
-test("returns false for null values compared with objects", async () => {
+it("should return false for null values compared with objects", async () => {
     const obj = { a: 1 };
     const result = isDeepEqualData(obj, null);
     assert.equal(result, false);
 });
-test("identifies two equal objects", async () => {
+it("should identify two equal objects", async () => {
     const obj1 = { a: 1, b: 2 };
     const obj2 = { a: 1, b: 2 };
     const result = isDeepEqualData(obj1, obj2);
     assert.equal(result, true);
 });
-test("identifies two objects with different values", async () => {
+it("should identify two objects with different values", async () => {
     const obj1 = { a: 1, b: 2 };
     const obj2 = { a: 1, b: 3 };
     const result = isDeepEqualData(obj1, obj2);
     assert.equal(result, false);
 });
-test("identifies two objects with different number of keys", async () => {
+it("should identify two objects with different number of keys", async () => {
     const obj1 = { a: 1, b: 2 };
     const obj2 = { a: 1, b: 2, c: 3 };
     const result = isDeepEqualData(obj1, obj2);
     assert.equal(result, false);
 });
-test("handles nested objects", async () => {
+it("should handle nested objects", async () => {
     const obj1 = { a: { c: 1 }, b: 2 };
     const obj2 = { a: { c: 1 }, b: 2 };
     const result = isDeepEqualData(obj1, obj2);
     assert.equal(result, true);
 });
-test("detects inequality in nested objects", async () => {
+it("should detect inequality in nested objects", async () => {
     const obj1 = { a: { c: 1 }, b: 2 };
     const obj2 = { a: { c: 2 }, b: 2 };
     const result = isDeepEqualData(obj1, obj2);
     assert.equal(result, false);
 });
-test("compares arrays correctly", async () => {
+it("should compare arrays correctly", async () => {
     const arr1 = [1, 2, 3];
     const arr2 = [1, 2, 3];
     const result = isDeepEqualData(arr1, arr2);
@@ -62,18 +61,18 @@ test("compares arrays correctly", async () => {
     const result2 = isDeepEqualData(arr3, arr4);
     assert.equal(result2, false);
 });
-test("returns false for null comparison with object", () => {
+it("should return false for null comparison with object", () => {
     const obj = { a: 1 };
     const result = isDeepEqualData(obj, null);
     assert.equal(result, false);
 });
-test("distinguishes between array and object with same enumerable properties", () => {
+it("should distinguish between array and object with same enumerable properties", () => {
     const obj = { 0: "one", 1: "two", length: 2 };
     const arr = ["one", "two"];
     const result = isDeepEqualData(obj, arr);
     assert.equal(result, false);
 });
-test("returns false when comparing objects with different prototypes", () => {
+it("should return false when comparing objects with different prototypes", () => {
     const obj1 = Object.create({ a: 1 });
     const obj2 = Object.create(null);
     obj1.b = 2;
@@ -81,14 +80,14 @@ test("returns false when comparing objects with different prototypes", () => {
     const result = isDeepEqualData(obj1, obj2);
     assert.equal(result, false);
 });
-test("handles date object comparisons correctly", () => {
+it("should handle date object comparisons correctly", () => {
     const date1 = new Date(2000, 0, 1);
     const date2 = new Date(2000, 0, 1);
     const date3 = new Date(2000, 0, 2);
     assert.equal(isDeepEqualData(date1, date2), true);
     assert.equal(isDeepEqualData(date1, date3), false);
 });
-test("handles function comparisons", () => {
+it("should handle function comparisons", () => {
     const func1 = () => {
         console.log("hello");
     };

package/util/runSafe.test.cjs

@@ -1,58 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
 const runSafe_js_1 = require("./runSafe.cjs");
-(0, vitest_1.test)("catch thrown error in sync function", async () => {
+it("should catch thrown error in sync function", async () => {
     const error = new Error("test error");
     const result = await (0, runSafe_js_1.runSafe)(() => {
         throw error;
     });
-    (0, vitest_1.expect)(result).toEqual({
+    expect(result).toEqual({
         ok: false,
         error,
     });
 });
-(0, vitest_1.test)("catch thrown string in sync function", async () => {
+it("should catch thrown string in sync function", async () => {
     const result = await (0, runSafe_js_1.runSafe)(() => {
         throw "test error";
     });
-    (0, vitest_1.expect)(result).toEqual({
+    expect(result).toEqual({
         ok: false,
         error: "test error",
     });
 });
-(0, vitest_1.test)("catch thrown error in async function", async () => {
+it("should catch thrown error in async function", async () => {
     const error = new Error("test error");
     const result = await (0, runSafe_js_1.runSafe)(async () => {
         throw error;
     });
-    (0, vitest_1.expect)(result).toEqual({
+    expect(result).toEqual({
         ok: false,
         error,
     });
 });
-(0, vitest_1.test)("catch thrown string in async function", async () => {
+it("should catch thrown string in async function", async () => {
     const result = await (0, runSafe_js_1.runSafe)(async () => {
         throw "test error";
     });
-    (0, vitest_1.expect)(result).toEqual({
+    expect(result).toEqual({
         ok: false,
         error: "test error",
     });
 });
-(0, vitest_1.test)("catch rejected Promise", async () => {
+it("should catch rejected Promise", async () => {
     const error = new Error("test error");
     const result = await (0, runSafe_js_1.runSafe)(async () => {
         return Promise.reject(error);
     });
-    (0, vitest_1.expect)(result).toEqual({
+    expect(result).toEqual({
         ok: false,
         error,
     });
 });
-(0, vitest_1.test)("no error", async () => {
+it("should not throw error", async () => {
     const result = await (0, runSafe_js_1.runSafe)(async () => "result");
-    (0, vitest_1.expect)(result).toEqual({
+    expect(result).toEqual({
         ok: true,
         value: "result",
     });

package/util/runSafe.test.js

@@ -1,6 +1,5 @@
-import { expect, test } from "vitest";
 import { runSafe } from "./runSafe.js";
-test("catch thrown error in sync function", async () => {
+it("should catch thrown error in sync function", async () => {
     const error = new Error("test error");
     const result = await runSafe(() => {
         throw error;
@@ -10,7 +9,7 @@ test("catch thrown error in sync function", async () => {
         error,
     });
 });
-test("catch thrown string in sync function", async () => {
+it("should catch thrown string in sync function", async () => {
     const result = await runSafe(() => {
         throw "test error";
     });
@@ -19,7 +18,7 @@ test("catch thrown string in sync function", async () => {
         error: "test error",
     });
 });
-test("catch thrown error in async function", async () => {
+it("should catch thrown error in async function", async () => {
     const error = new Error("test error");
     const result = await runSafe(async () => {
         throw error;
@@ -29,7 +28,7 @@ test("catch thrown error in async function", async () => {
         error,
     });
 });
-test("catch thrown string in async function", async () => {
+it("should catch thrown string in async function", async () => {
     const result = await runSafe(async () => {
         throw "test error";
     });
@@ -38,7 +37,7 @@ test("catch thrown string in async function", async () => {
         error: "test error",
     });
 });
-test("catch rejected Promise", async () => {
+it("should catch rejected Promise", async () => {
     const error = new Error("test error");
     const result = await runSafe(async () => {
         return Promise.reject(error);
@@ -48,7 +47,7 @@ test("catch rejected Promise", async () => {
         error,
     });
 });
-test("no error", async () => {
+it("should not throw error", async () => {
     const result = await runSafe(async () => "result");
     expect(result).toEqual({
         ok: true,

package/core/GlobalFunctionLogging.cjs

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGlobalFunctionLogging = exports.setGlobalFunctionLogging = void 0;
-let globalFunctionLogging = undefined;
-function setGlobalFunctionLogging(logLevel) {
-    globalFunctionLogging = logLevel;
-}
-exports.setGlobalFunctionLogging = setGlobalFunctionLogging;
-function getGlobalFunctionLogging() {
-    return globalFunctionLogging;
-}
-exports.getGlobalFunctionLogging = getGlobalFunctionLogging;

package/core/GlobalFunctionLogging.d.ts

@@ -1,3 +0,0 @@
-import { FunctionLogging } from "./FunctionOptions.js";
-export declare function setGlobalFunctionLogging(logLevel: FunctionLogging): void;
-export declare function getGlobalFunctionLogging(): FunctionLogging;

package/core/GlobalFunctionLogging.js

@@ -1,7 +0,0 @@
-let globalFunctionLogging = undefined;
-export function setGlobalFunctionLogging(logLevel) {
-    globalFunctionLogging = logLevel;
-}
-export function getGlobalFunctionLogging() {
-    return globalFunctionLogging;
-}

package/core/GlobalFunctionObservers.cjs

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGlobalFunctionObservers = exports.setGlobalFunctionObservers = void 0;
-let globalFunctionObservers = [];
-function setGlobalFunctionObservers(functionObservers) {
-    globalFunctionObservers = functionObservers;
-}
-exports.setGlobalFunctionObservers = setGlobalFunctionObservers;
-function getGlobalFunctionObservers() {
-    return globalFunctionObservers;
-}
-exports.getGlobalFunctionObservers = getGlobalFunctionObservers;

package/core/GlobalFunctionObservers.d.ts

@@ -1,3 +0,0 @@
-import { FunctionObserver } from "./FunctionObserver.js";
-export declare function setGlobalFunctionObservers(functionObservers: FunctionObserver[]): void;
-export declare function getGlobalFunctionObservers(): FunctionObserver[];

package/core/GlobalFunctionObservers.js

@@ -1,7 +0,0 @@
-let globalFunctionObservers = [];
-export function setGlobalFunctionObservers(functionObservers) {
-    globalFunctionObservers = functionObservers;
-}
-export function getGlobalFunctionObservers() {
-    return globalFunctionObservers;
-}