modelfusion 0.47.0 → 0.47.2

package/model-provider/openai/chat/OpenAIChatModel.cjs

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIChatResponseFormat = exports.OpenAIChatModel = exports.calculateOpenAIChatCostInMillicents = exports.isOpenAIChatModel = exports.getOpenAIChatModelInformation = exports.OPENAI_CHAT_MODELS = void 0;
 const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
-const zod_1 = __importDefault(require("zod"));
+const zod_1 = require("zod");
 const callWithRetryAndThrottle_js_1 = require("../../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../../core/api/postToApi.cjs");
 const AbstractModel_js_1 = require("../../../model-function/AbstractModel.cjs");
@@ -270,7 +270,7 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
         catch (error) {
             throw new StructureParseError_js_1.StructureParseError({
                 structureName: structureDefinition.name,
-                valueText: valueText,
+                valueText,
                 cause: error,
             });
         }
@@ -370,30 +370,30 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
     }
 }
 exports.OpenAIChatModel = OpenAIChatModel;
-const openAIChatResponseSchema = zod_1.default.object({
-    id: zod_1.default.string(),
-    object: zod_1.default.literal("chat.completion"),
-    created: zod_1.default.number(),
-    model: zod_1.default.string(),
-    choices: zod_1.default.array(zod_1.default.object({
-        message: zod_1.default.object({
-            role: zod_1.default.literal("assistant"),
-            content: zod_1.default.string().nullable(),
-            function_call: zod_1.default
+const openAIChatResponseSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    object: zod_1.z.literal("chat.completion"),
+    created: zod_1.z.number(),
+    model: zod_1.z.string(),
+    choices: zod_1.z.array(zod_1.z.object({
+        message: zod_1.z.object({
+            role: zod_1.z.literal("assistant"),
+            content: zod_1.z.string().nullable(),
+            function_call: zod_1.z
                 .object({
-                name: zod_1.default.string(),
-                arguments: zod_1.default.string(),
+                name: zod_1.z.string(),
+                arguments: zod_1.z.string(),
             })
                 .optional(),
         }),
-        index: zod_1.default.number(),
-        logprobs: zod_1.default.nullable(zod_1.default.any()),
-        finish_reason: zod_1.default.string(),
+        index: zod_1.z.number(),
+        logprobs: zod_1.z.nullable(zod_1.z.any()),
+        finish_reason: zod_1.z.string(),
     })),
-    usage: zod_1.default.object({
-        prompt_tokens: zod_1.default.number(),
-        completion_tokens: zod_1.default.number(),
-        total_tokens: zod_1.default.number(),
+    usage: zod_1.z.object({
+        prompt_tokens: zod_1.z.number(),
+        completion_tokens: zod_1.z.number(),
+        total_tokens: zod_1.z.number(),
     }),
 });
 async function callOpenAIChatCompletionAPI({ api = new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration(), abortSignal, responseFormat, model, messages, functions, functionCall, temperature, topP, n, stop, maxTokens, presencePenalty, frequencyPenalty, logitBias, user, }) {

package/model-provider/openai/chat/OpenAIChatModel.d.ts

@@ -1,4 +1,4 @@
-import z from "zod";
+import { z } from "zod";
 import { FunctionOptions } from "../../../core/FunctionOptions.js";
 import { ApiConfiguration } from "../../../core/api/ApiConfiguration.js";
 import { ResponseHandler } from "../../../core/api/postToApi.js";

package/model-provider/openai/chat/OpenAIChatModel.js

@@ -1,5 +1,5 @@
 import SecureJSON from "secure-json-parse";
-import z from "zod";
+import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../../core/api/postToApi.js";
 import { AbstractModel } from "../../../model-function/AbstractModel.js";
@@ -261,7 +261,7 @@ export class OpenAIChatModel extends AbstractModel {
         catch (error) {
             throw new StructureParseError({
                 structureName: structureDefinition.name,
-                valueText: valueText,
+                valueText,
                 cause: error,
             });
         }

package/model-provider/openai/chat/OpenAIChatStreamIterable.cjs

@@ -1,13 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOpenAIChatDeltaIterableQueue = void 0;
-const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
 const zod_1 = require("zod");
 const AsyncQueue_js_1 = require("../../../event-source/AsyncQueue.cjs");
 const parseEventSourceStream_js_1 = require("../../../event-source/parseEventSourceStream.cjs");
+const parseJSON_js_1 = require("../../../util/parseJSON.cjs");
 const chatResponseStreamEventSchema = zod_1.z.object({
     choices: zod_1.z.array(zod_1.z.object({
         delta: zod_1.z.object({
@@ -41,8 +38,7 @@ async function createOpenAIChatDeltaIterableQueue(stream, extractDeltaValue) {
                     queue.close();
                     return;
                 }
-                const json = secure_json_parse_1.default.parse(data);
-                const parseResult = chatResponseStreamEventSchema.safeParse(json);
+                const parseResult = (0, parseJSON_js_1.safeParseJsonWithZod)(data, chatResponseStreamEventSchema);
                 if (!parseResult.success) {
                     queue.push({
                         type: "error",

package/model-provider/openai/chat/OpenAIChatStreamIterable.js

@@ -1,7 +1,7 @@
-import SecureJSON from "secure-json-parse";
 import { z } from "zod";
 import { AsyncQueue } from "../../../event-source/AsyncQueue.js";
 import { parseEventSourceStream } from "../../../event-source/parseEventSourceStream.js";
+import { safeParseJsonWithZod } from "../../../util/parseJSON.js";
 const chatResponseStreamEventSchema = z.object({
     choices: z.array(z.object({
         delta: z.object({
@@ -35,8 +35,7 @@ export async function createOpenAIChatDeltaIterableQueue(stream, extractDeltaVal
                     queue.close();
                     return;
                 }
-                const json = SecureJSON.parse(data);
-                const parseResult = chatResponseStreamEventSchema.safeParse(json);
+                const parseResult = safeParseJsonWithZod(data, chatResponseStreamEventSchema);
                 if (!parseResult.success) {
                     queue.push({
                         type: "error",

package/model-provider/stability/StabilityError.cjs

@@ -1,12 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.failedStabilityCallResponseHandler = exports.StabilityError = exports.stabilityErrorDataSchema = void 0;
-const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
 const zod_1 = require("zod");
 const ApiCallError_js_1 = require("../../core/api/ApiCallError.cjs");
+const parseJSON_js_1 = require("../../util/parseJSON.cjs");
 exports.stabilityErrorDataSchema = zod_1.z.object({
     message: zod_1.z.string(),
 });
@@ -25,7 +22,7 @@ class StabilityError extends ApiCallError_js_1.ApiCallError {
 exports.StabilityError = StabilityError;
 const failedStabilityCallResponseHandler = async ({ response, url, requestBodyValues }) => {
     const responseBody = await response.text();
-    const parsedError = exports.stabilityErrorDataSchema.parse(secure_json_parse_1.default.parse(responseBody));
+    const parsedError = (0, parseJSON_js_1.parseJsonWithZod)(responseBody, exports.stabilityErrorDataSchema);
     return new StabilityError({
         url,
         requestBodyValues,

package/model-provider/stability/StabilityError.js

@@ -1,6 +1,6 @@
-import SecureJSON from "secure-json-parse";
 import { z } from "zod";
 import { ApiCallError } from "../../core/api/ApiCallError.js";
+import { parseJsonWithZod } from "../../util/parseJSON.js";
 export const stabilityErrorDataSchema = z.object({
     message: z.string(),
 });
@@ -18,7 +18,7 @@ export class StabilityError extends ApiCallError {
 }
 export const failedStabilityCallResponseHandler = async ({ response, url, requestBodyValues }) => {
     const responseBody = await response.text();
-    const parsedError = stabilityErrorDataSchema.parse(SecureJSON.parse(responseBody));
+    const parsedError = parseJsonWithZod(responseBody, stabilityErrorDataSchema);
     return new StabilityError({
         url,
         requestBodyValues,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "Build multimodal applications, chatbots, and agents with JavaScript and TypeScript.",
-  "version": "0.47.0",
+  "version": "0.47.2",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [
@@ -47,12 +47,12 @@
     "build": "npm run build:esm && npm run build:cjs",
     "build:esm": "tsc --outDir dist/",
     "build:cjs": "tsc --outDir build/cjs/ -p tsconfig.cjs.json && node bin/prepare-cjs.js",
-    "test": "vitest",
-    "dist": "npm run clean && npm run lint && npm run build && npm run dist:copy-files",
+    "test": "vitest run src",
+    "test-interactive": "vitest run",
+    "dist": "npm run clean && npm run lint && npm run test && npm run build && npm run dist:copy-files",
     "dist:copy-files": "copyfiles package.json README.md LICENSE dist"
   },
   "dependencies": {
-    "deep-equal": "2.2.2",
     "eventsource-parser": "1.1.1",
     "js-tiktoken": "1.0.7",
     "nanoid": "3.3.6",

package/util/JSONParseError.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONParseError = void 0;
+const getErrorMessage_js_1 = require("./getErrorMessage.cjs");
+class JSONParseError extends Error {
+    constructor({ valueText, cause }) {
+        super(`JSON parsing failed: ` +
+            `Value: ${valueText}.\n` +
+            `Error message: ${(0, getErrorMessage_js_1.getErrorMessage)(cause)}`);
+        Object.defineProperty(this, "structureName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "valueText", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "JSONParseError";
+        this.cause = cause;
+        this.valueText = valueText;
+    }
+}
+exports.JSONParseError = JSONParseError;

package/util/JSONParseError.d.ts

@@ -0,0 +1,9 @@
+export declare class JSONParseError extends Error {
+    readonly structureName: string;
+    readonly cause: unknown;
+    readonly valueText: string;
+    constructor({ valueText, cause }: {
+        valueText: string;
+        cause: unknown;
+    });
+}

package/util/JSONParseError.js

@@ -0,0 +1,29 @@
+import { getErrorMessage } from "./getErrorMessage.js";
+export class JSONParseError extends Error {
+    constructor({ valueText, cause }) {
+        super(`JSON parsing failed: ` +
+            `Value: ${valueText}.\n` +
+            `Error message: ${getErrorMessage(cause)}`);
+        Object.defineProperty(this, "structureName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "valueText", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "JSONParseError";
+        this.cause = cause;
+        this.valueText = valueText;
+    }
+}

package/util/index.cjs

@@ -14,5 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./JSONParseError.cjs"), exports);
 __exportStar(require("./cosineSimilarity.cjs"), exports);
 __exportStar(require("./getAudioFileExtension.cjs"), exports);
+__exportStar(require("./parseJSON.cjs"), exports);

package/util/index.d.ts

@@ -1,2 +1,4 @@
+export * from "./JSONParseError.js";
 export * from "./cosineSimilarity.js";
 export * from "./getAudioFileExtension.js";
+export * from "./parseJSON.js";

package/util/index.js

@@ -1,2 +1,4 @@
+export * from "./JSONParseError.js";
 export * from "./cosineSimilarity.js";
 export * from "./getAudioFileExtension.js";
+export * from "./parseJSON.js";

package/util/isDeepEqualData.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDeepEqualData = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Performs a deep-equal comparison of two parsed JSON structures.
+ *
+ * @param {any} obj1 - The first object to compare.
+ * @param {any} obj2 - The second object to compare.
+ * @returns {boolean} - Returns true if the two objects are deeply equal, false otherwise.
+ */
+function isDeepEqualData(obj1, obj2) {
+    // Check for strict equality first
+    if (obj1 === obj2)
+        return true;
+    // Check if either is null or undefined
+    if (obj1 == null || obj2 == null)
+        return false;
+    // Check if both are objects
+    if (typeof obj1 !== "object" && typeof obj2 !== "object")
+        return obj1 === obj2;
+    // If they are not strictly equal, they both need to be Objects
+    if (obj1.constructor !== obj2.constructor)
+        return false;
+    // Special handling for Date objects
+    if (obj1 instanceof Date && obj2 instanceof Date) {
+        return obj1.getTime() === obj2.getTime();
+    }
+    // Handle arrays: compare length and then perform a recursive deep comparison on each item
+    if (Array.isArray(obj1)) {
+        if (obj1.length !== obj2.length)
+            return false;
+        for (let i = 0; i < obj1.length; i++) {
+            if (!isDeepEqualData(obj1[i], obj2[i]))
+                return false;
+        }
+        return true; // All array elements matched
+    }
+    // Compare the set of keys in each object
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length)
+        return false;
+    // Check each key-value pair recursively
+    for (const key of keys1) {
+        if (!keys2.includes(key))
+            return false;
+        if (!isDeepEqualData(obj1[key], obj2[key]))
+            return false;
+    }
+    return true; // All keys and values matched
+}
+exports.isDeepEqualData = isDeepEqualData;

package/util/isDeepEqualData.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Performs a deep-equal comparison of two parsed JSON structures.
+ *
+ * @param {any} obj1 - The first object to compare.
+ * @param {any} obj2 - The second object to compare.
+ * @returns {boolean} - Returns true if the two objects are deeply equal, false otherwise.
+ */
+export declare function isDeepEqualData(obj1: any, obj2: any): boolean;

package/util/isDeepEqualData.js

@@ -0,0 +1,49 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Performs a deep-equal comparison of two parsed JSON structures.
+ *
+ * @param {any} obj1 - The first object to compare.
+ * @param {any} obj2 - The second object to compare.
+ * @returns {boolean} - Returns true if the two objects are deeply equal, false otherwise.
+ */
+export function isDeepEqualData(obj1, obj2) {
+    // Check for strict equality first
+    if (obj1 === obj2)
+        return true;
+    // Check if either is null or undefined
+    if (obj1 == null || obj2 == null)
+        return false;
+    // Check if both are objects
+    if (typeof obj1 !== "object" && typeof obj2 !== "object")
+        return obj1 === obj2;
+    // If they are not strictly equal, they both need to be Objects
+    if (obj1.constructor !== obj2.constructor)
+        return false;
+    // Special handling for Date objects
+    if (obj1 instanceof Date && obj2 instanceof Date) {
+        return obj1.getTime() === obj2.getTime();
+    }
+    // Handle arrays: compare length and then perform a recursive deep comparison on each item
+    if (Array.isArray(obj1)) {
+        if (obj1.length !== obj2.length)
+            return false;
+        for (let i = 0; i < obj1.length; i++) {
+            if (!isDeepEqualData(obj1[i], obj2[i]))
+                return false;
+        }
+        return true; // All array elements matched
+    }
+    // Compare the set of keys in each object
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length)
+        return false;
+    // Check each key-value pair recursively
+    for (const key of keys1) {
+        if (!keys2.includes(key))
+            return false;
+        if (!isDeepEqualData(obj1[key], obj2[key]))
+            return false;
+    }
+    return true; // All keys and values matched
+}

package/util/isDeepEqualData.test.cjs

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 () => {
+    let x = 1;
+    let y = 1;
+    let result = (0, isDeepEqualData_js_1.isDeepEqualData)(x, y);
+    node_assert_1.default.equal(result, true);
+    x = 1;
+    y = 2;
+    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 () => {
+    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 () => {
+    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 () => {
+    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 () => {
+    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 () => {
+    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 () => {
+    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 () => {
+    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 () => {
+    const arr1 = [1, 2, 3];
+    const arr2 = [1, 2, 3];
+    const result = (0, isDeepEqualData_js_1.isDeepEqualData)(arr1, arr2);
+    node_assert_1.default.equal(result, true);
+    const arr3 = [1, 2, 3];
+    const arr4 = [1, 2, 4];
+    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", () => {
+    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", () => {
+    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", () => {
+    const obj1 = Object.create({ a: 1 });
+    const obj2 = Object.create(null);
+    obj1.b = 2;
+    obj2.b = 2;
+    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", () => {
+    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", () => {
+    const func1 = () => {
+        console.log("hello");
+    };
+    const func2 = () => {
+        console.log("hello");
+    };
+    const func3 = () => {
+        console.log("world");
+    };
+    node_assert_1.default.equal((0, isDeepEqualData_js_1.isDeepEqualData)(func1, func2), false);
+    node_assert_1.default.equal((0, isDeepEqualData_js_1.isDeepEqualData)(func1, func3), false);
+});

package/util/isDeepEqualData.test.d.ts

@@ -0,0 +1 @@
+export {};

package/util/isDeepEqualData.test.js

@@ -0,0 +1,103 @@
+import assert from "node:assert";
+import { test } from "vitest";
+import { isDeepEqualData } from "./isDeepEqualData.js";
+test("checks if two primitives are equal", async () => {
+    let x = 1;
+    let y = 1;
+    let result = isDeepEqualData(x, y);
+    assert.equal(result, true);
+    x = 1;
+    y = 2;
+    result = isDeepEqualData(x, y);
+    assert.equal(result, false);
+});
+test("returns 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 () => {
+    const obj = { a: 1 };
+    const result = isDeepEqualData(obj, null);
+    assert.equal(result, false);
+});
+test("identifies 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 () => {
+    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 () => {
+    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 () => {
+    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 () => {
+    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 () => {
+    const arr1 = [1, 2, 3];
+    const arr2 = [1, 2, 3];
+    const result = isDeepEqualData(arr1, arr2);
+    assert.equal(result, true);
+    const arr3 = [1, 2, 3];
+    const arr4 = [1, 2, 4];
+    const result2 = isDeepEqualData(arr3, arr4);
+    assert.equal(result2, false);
+});
+test("returns 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", () => {
+    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", () => {
+    const obj1 = Object.create({ a: 1 });
+    const obj2 = Object.create(null);
+    obj1.b = 2;
+    obj2.b = 2;
+    const result = isDeepEqualData(obj1, obj2);
+    assert.equal(result, false);
+});
+test("handles 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", () => {
+    const func1 = () => {
+        console.log("hello");
+    };
+    const func2 = () => {
+        console.log("hello");
+    };
+    const func3 = () => {
+        console.log("world");
+    };
+    assert.equal(isDeepEqualData(func1, func2), false);
+    assert.equal(isDeepEqualData(func1, func3), false);
+});