@unrift/core 0.0.0

package/dist/esm/utils/colors.js

@@ -0,0 +1,12 @@
+const enabled = process.stdout.isTTY &&
+    process.env.NO_COLOR !== "1" &&
+    process.env.NO_COLOR !== "true";
+function wrap(code) {
+    return (text) => (enabled ? `\x1b[${code}m${text}\x1b[0m` : text);
+}
+export const colors = {
+    green: wrap(32),
+    red: wrap(31),
+    yellow: wrap(33),
+    bold: wrap(1),
+};

package/dist/esm/utils/deepEqual.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Deep structural equality with:
+ * - Value semantics for primitives (+ NaN equal, +0/-0 equal)
+ * - Structural comparison for Arrays, Maps, Sets, TypedArrays, ArrayBuffer, DataView, Date, RegExp
+ * - Prototype-sensitive object comparison
+ * - Handles circular references
+ */
+export declare function deepEqual<T>(a: T, b: T): boolean;
+//# sourceMappingURL=deepEqual.d.ts.map

package/dist/esm/utils/deepEqual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepEqual.d.ts","sourceRoot":"","sources":["../../../src/utils/deepEqual.ts"],"names":[],"mappings":"AA+OA;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,CAShD"}

package/dist/esm/utils/deepEqual.js

@@ -0,0 +1,201 @@
+import { isObjectLike, isPrimitive, isTypedArray, sameValue, } from "./helpers.js";
+function deepEqualInternal(left, right, leftToRightSeen) {
+    const worklist = [[left, right]];
+    while (worklist.length) {
+        const [currentLeft, currentRight] = worklist.pop();
+        if (sameValue(currentLeft, currentRight))
+            continue;
+        // Types must match at this point
+        if (typeof currentLeft !== typeof currentRight)
+            return false;
+        // Primitive mismatch - we already handled equality above
+        if (isPrimitive(currentLeft) || isPrimitive(currentRight))
+            return false;
+        // Functions, etc. – only ever equal by reference, which we've already checked
+        if (!isObjectLike(currentLeft) || !isObjectLike(currentRight))
+            return false;
+        const leftObj = currentLeft;
+        const rightObj = currentRight;
+        // Cycle detection: require consistent mapping for left-side objects
+        const previouslyMappedRight = leftToRightSeen.get(leftObj);
+        if (previouslyMappedRight !== undefined) {
+            if (previouslyMappedRight !== rightObj)
+                return false;
+            continue;
+        }
+        leftToRightSeen.set(leftObj, rightObj);
+        // Arrays - prototype-sensitive handled by prototype check later
+        const leftIsArray = Array.isArray(currentLeft);
+        const rightIsArray = Array.isArray(currentRight);
+        if (leftIsArray || rightIsArray) {
+            if (!leftIsArray || !rightIsArray)
+                return false;
+            const leftArr = currentLeft;
+            const rightArr = currentRight;
+            if (leftArr.length !== rightArr.length)
+                return false;
+            // Preserve sparseness by reading indexed values directly.
+            for (let index = 0; index < leftArr.length; index++) {
+                worklist.push([leftArr[index], rightArr[index]]);
+            }
+            continue;
+        }
+        // Typed arrays
+        const leftIsTyped = isTypedArray(currentLeft);
+        const rightIsTyped = isTypedArray(currentRight);
+        if (leftIsTyped || rightIsTyped) {
+            if (!leftIsTyped || !rightIsTyped)
+                return false;
+            const leftTA = currentLeft;
+            const rightTA = currentRight;
+            if (leftTA.constructor !== rightTA.constructor)
+                return false;
+            if (leftTA.length !== rightTA.length)
+                return false;
+            for (let index = 0; index < leftTA.length; index++) {
+                if (!sameValue(leftTA[index], rightTA[index]))
+                    return false;
+            }
+            continue;
+        }
+        // ArrayBuffer
+        const leftIsBuffer = currentLeft instanceof ArrayBuffer;
+        const rightIsBuffer = currentRight instanceof ArrayBuffer;
+        if (leftIsBuffer || rightIsBuffer) {
+            if (!leftIsBuffer || !rightIsBuffer)
+                return false;
+            const leftBuf = currentLeft;
+            const rightBuf = currentRight;
+            if (leftBuf.byteLength !== rightBuf.byteLength)
+                return false;
+            const leftBytes = new Uint8Array(leftBuf);
+            const rightBytes = new Uint8Array(rightBuf);
+            for (let index = 0; index < leftBytes.length; index++) {
+                if (leftBytes[index] !== rightBytes[index])
+                    return false;
+            }
+            continue;
+        }
+        // DataView
+        const leftIsView = currentLeft instanceof DataView;
+        const rightIsView = currentRight instanceof DataView;
+        if (leftIsView || rightIsView) {
+            if (!leftIsView || !rightIsView)
+                return false;
+            const leftView = currentLeft;
+            const rightView = currentRight;
+            if (leftView.byteLength !== rightView.byteLength)
+                return false;
+            for (let offset = 0; offset < leftView.byteLength; offset++) {
+                if (leftView.getUint8(offset) !== rightView.getUint8(offset))
+                    return false;
+            }
+            continue;
+        }
+        // Date
+        const leftIsDate = currentLeft instanceof Date;
+        const rightIsDate = currentRight instanceof Date;
+        if (leftIsDate || rightIsDate) {
+            if (!leftIsDate || !rightIsDate)
+                return false;
+            if (currentLeft.getTime() !== currentRight.getTime())
+                return false;
+            continue;
+        }
+        // RegExp
+        const leftIsRegExp = currentLeft instanceof RegExp;
+        const rightIsRegExp = currentRight instanceof RegExp;
+        if (leftIsRegExp || rightIsRegExp) {
+            if (!leftIsRegExp || !rightIsRegExp)
+                return false;
+            const leftRe = currentLeft;
+            const rightRe = currentRight;
+            if (leftRe.source !== rightRe.source)
+                return false;
+            if (leftRe.flags !== rightRe.flags)
+                return false;
+            continue;
+        }
+        // Set
+        const leftIsSet = currentLeft instanceof Set;
+        const rightIsSet = currentRight instanceof Set;
+        if (leftIsSet || rightIsSet) {
+            if (!leftIsSet || !rightIsSet)
+                return false;
+            const leftSet = currentLeft;
+            const rightSet = currentRight;
+            if (leftSet.size !== rightSet.size)
+                return false;
+            const unmatchedRightValues = new Set(rightSet);
+            outer: for (const leftValue of leftSet) {
+                for (const rightValue of unmatchedRightValues) {
+                    if (deepEqualInternal(leftValue, rightValue, leftToRightSeen)) {
+                        unmatchedRightValues.delete(rightValue);
+                        continue outer;
+                    }
+                }
+                return false;
+            }
+            continue;
+        }
+        // Map
+        const leftIsMap = currentLeft instanceof Map;
+        const rightIsMap = currentRight instanceof Map;
+        if (leftIsMap || rightIsMap) {
+            if (!leftIsMap || !rightIsMap)
+                return false;
+            const leftMap = currentLeft;
+            const rightMap = currentRight;
+            if (leftMap.size !== rightMap.size)
+                return false;
+            const unmatchedRightEntries = new Set(rightMap.entries());
+            outer: for (const [leftKey, leftValue] of leftMap.entries()) {
+                for (const candidate of unmatchedRightEntries) {
+                    const [rightKey, rightValue] = candidate;
+                    if (deepEqualInternal(leftKey, rightKey, leftToRightSeen) &&
+                        deepEqualInternal(leftValue, rightValue, leftToRightSeen)) {
+                        unmatchedRightEntries.delete(candidate);
+                        continue outer;
+                    }
+                }
+                return false;
+            }
+            continue;
+        }
+        // Fallback: plain objects / custom class instances (prototype-sensitive)
+        const leftProto = Object.getPrototypeOf(currentLeft);
+        const rightProto = Object.getPrototypeOf(currentRight);
+        if (leftProto !== rightProto)
+            return false;
+        const leftKeys = Object.keys(currentLeft);
+        const rightKeys = Object.keys(currentRight);
+        if (leftKeys.length !== rightKeys.length)
+            return false;
+        const leftRecord = currentLeft;
+        const rightRecord = currentRight;
+        for (let i = 0; i < leftKeys.length; i++) {
+            const key = leftKeys[i];
+            if (!Object.hasOwn(rightRecord, key))
+                return false;
+            worklist.push([leftRecord[key], rightRecord[key]]);
+        }
+    }
+    return true;
+}
+/**
+ * Deep structural equality with:
+ * - Value semantics for primitives (+ NaN equal, +0/-0 equal)
+ * - Structural comparison for Arrays, Maps, Sets, TypedArrays, ArrayBuffer, DataView, Date, RegExp
+ * - Prototype-sensitive object comparison
+ * - Handles circular references
+ */
+export function deepEqual(a, b) {
+    if (sameValue(a, b))
+        return true;
+    // Fast-path for primitive inequality
+    if (isPrimitive(a) || isPrimitive(b))
+        return false;
+    if (!isObjectLike(a) || !isObjectLike(b))
+        return false;
+    return deepEqualInternal(a, b, new WeakMap());
+}

package/dist/esm/utils/defineConfig.d.ts

@@ -0,0 +1,12 @@
+export interface UnriftConfigOptions {
+    testDir?: string;
+    rootDir?: string;
+    timeoutMs?: number;
+    bail?: boolean;
+    pattern?: string;
+    includes?: string[];
+    excludes?: string[];
+    matchers?: string[];
+}
+export declare function defineConfig(options: UnriftConfigOptions): UnriftConfigOptions;
+//# sourceMappingURL=defineConfig.d.ts.map

package/dist/esm/utils/defineConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineConfig.d.ts","sourceRoot":"","sources":["../../../src/utils/defineConfig.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,wBAAgB,YAAY,CAC1B,OAAO,EAAE,mBAAmB,GAC3B,mBAAmB,CAErB"}

package/dist/esm/utils/defineConfig.js

@@ -0,0 +1,3 @@
+export function defineConfig(options) {
+    return options;
+}

package/dist/esm/utils/discoverTestFiles.d.ts

@@ -0,0 +1,3 @@
+export declare function isTestFileName(name: string): boolean;
+export declare function discoverTestFiles(dir: string): string[];
+//# sourceMappingURL=discoverTestFiles.d.ts.map

package/dist/esm/utils/discoverTestFiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discoverTestFiles.d.ts","sourceRoot":"","sources":["../../../src/utils/discoverTestFiles.ts"],"names":[],"mappings":"AAGA,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAqBvD"}

package/dist/esm/utils/discoverTestFiles.js

@@ -0,0 +1,22 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+export function isTestFileName(name) {
+    return /\.(spec|test)\.(ts|js)$/.test(name);
+}
+export function discoverTestFiles(dir) {
+    if (!existsSync(dir))
+        return [];
+    const entries = readdirSync(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...discoverTestFiles(fullPath));
+            continue;
+        }
+        if (entry.isFile() && isTestFileName(entry.name)) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}

package/dist/esm/utils/helpers.d.ts

@@ -0,0 +1,13 @@
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+export type TypedArray = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+export declare function isPrimitive(value: unknown): value is Primitive;
+export declare function isObjectLike(value: unknown): value is object;
+export declare function isTypedArray(value: unknown): value is TypedArray;
+/**
+ * SameValueZero-ish semantics:
+ * - NaN equals NaN
+ * - +0 and -0 are equal
+ */
+export declare function sameValue(a: unknown, b: unknown): boolean;
+export {};
+//# sourceMappingURL=helpers.d.ts.map

package/dist/esm/utils/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/helpers.ts"],"names":[],"mappings":"AAAA,KAAK,SAAS,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;AAEhF,MAAM,MAAM,UAAU,GAClB,UAAU,GACV,SAAS,GACT,WAAW,GACX,UAAU,GACV,WAAW,GACX,UAAU,GACV,YAAY,GACZ,YAAY,GACZ,aAAa,GACb,cAAc,CAAC;AAEnB,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAY9D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE5D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CASzD"}

package/dist/esm/utils/helpers.js

@@ -0,0 +1,29 @@
+export function isPrimitive(value) {
+    const t = typeof value;
+    return (value === null ||
+        t === "string" ||
+        t === "number" ||
+        t === "boolean" ||
+        t === "undefined" ||
+        t === "symbol" ||
+        t === "bigint");
+}
+export function isObjectLike(value) {
+    return typeof value === "object" && value !== null;
+}
+export function isTypedArray(value) {
+    return ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+/**
+ * SameValueZero-ish semantics:
+ * - NaN equals NaN
+ * - +0 and -0 are equal
+ */
+export function sameValue(a, b) {
+    if (a === b)
+        return true;
+    return (typeof a === "number" &&
+        typeof b === "number" &&
+        Number.isNaN(a) &&
+        Number.isNaN(b));
+}

package/dist/esm/utils/loadConfig.d.ts

@@ -0,0 +1,9 @@
+import type { UnriftConfigOptions } from "./defineConfig";
+export type LoadedConfig = {
+    config: UnriftConfigOptions;
+    configPath: string;
+    configDir: string;
+};
+export declare function loadConfigFromPath(configPath: string): Promise<LoadedConfig>;
+export declare function loadConfig(startDir: string): Promise<LoadedConfig | null>;
+//# sourceMappingURL=loadConfig.d.ts.map

package/dist/esm/utils/loadConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadConfig.d.ts","sourceRoot":"","sources":["../../../src/utils/loadConfig.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAU1D,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,mBAAmB,CAAC;IAE5B,UAAU,EAAE,MAAM,CAAC;IAEnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAuCF,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,YAAY,CAAC,CAevB;AAqCD,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAc9B"}

package/dist/esm/utils/loadConfig.js

@@ -0,0 +1,89 @@
+import { toImportUrl } from "./transform.js";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+/**
+ * Regex to match valid Unrift config file names.
+ * Matches:
+ * - unrift.config.ts/js/mjs/cjs/json
+ * - unrift.<anything>.config.ts/js/mjs/cjs/json  (e.g. unrift.only.config.mjs)
+ */
+const CONFIG_RE = /^unrift(?:\.[^.]+)*\.config\.(ts|js|mjs|cjs|json)$/;
+function isConfigFileName(name) {
+    return CONFIG_RE.test(name);
+}
+async function importConfigFile(configPath) {
+    if (configPath.endsWith(".json")) {
+        try {
+            const raw = readFileSync(configPath, "utf8");
+            return JSON.parse(raw);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`Failed to parse JSON config at ${configPath}: ${msg}`);
+        }
+    }
+    const module = await import(toImportUrl(configPath, "bundle-config"));
+    return module.default ?? module.config;
+}
+function assertConfigObject(config, absolutePath) {
+    if (!config || typeof config !== "object") {
+        throw new Error(`Unrift config at ${absolutePath} must export an object (default export recommended).`);
+    }
+}
+function toAbsolutePath(p) {
+    return isAbsolute(p) ? p : resolve(process.cwd(), p);
+}
+export async function loadConfigFromPath(configPath) {
+    const absolutePath = toAbsolutePath(configPath);
+    if (!existsSync(absolutePath)) {
+        throw new Error(`Config file not found: ${absolutePath}`);
+    }
+    const loaded = await importConfigFile(absolutePath);
+    assertConfigObject(loaded, absolutePath);
+    return {
+        config: loaded,
+        configPath: absolutePath,
+        configDir: dirname(absolutePath),
+    };
+}
+function findConfigPath(startDir) {
+    let dir = resolve(startDir);
+    while (true) {
+        let entries = [];
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            // ignore unreadable dirs
+        }
+        // Prefer the "default" config if multiple exist in same folder
+        const candidates = entries.filter(isConfigFileName).sort((a, b) => {
+            const aIsDefault = a.startsWith("unrift.config.");
+            const bIsDefault = b.startsWith("unrift.config.");
+            if (aIsDefault !== bIsDefault)
+                return aIsDefault ? -1 : 1;
+            return a.localeCompare(b);
+        });
+        if (candidates.length > 0) {
+            return join(dir, candidates[0]);
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+export async function loadConfig(startDir) {
+    const found = findConfigPath(startDir);
+    if (!found)
+        return null;
+    const absolutePath = toAbsolutePath(found);
+    const loaded = await importConfigFile(absolutePath);
+    assertConfigObject(loaded, absolutePath);
+    return {
+        config: loaded,
+        configPath: absolutePath,
+        configDir: dirname(absolutePath),
+    };
+}

package/dist/esm/utils/looseEqual.d.ts

@@ -0,0 +1,2 @@
+export declare function looseEqual<T>(left: T, right: T): boolean;
+//# sourceMappingURL=looseEqual.d.ts.map

package/dist/esm/utils/looseEqual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"looseEqual.d.ts","sourceRoot":"","sources":["../../../src/utils/looseEqual.ts"],"names":[],"mappings":"AAuRA,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAWxD"}

package/dist/esm/utils/looseEqual.js

@@ -0,0 +1,205 @@
+import { isObjectLike, isPrimitive, isTypedArray, sameValue, } from "./helpers.js";
+function looseEqualInternal(left, right, leftToRightSeen, rightToLeftSeen) {
+    const worklist = [[left, right]];
+    while (worklist.length) {
+        const [currentLeft, currentRight] = worklist.pop();
+        if (sameValue(currentLeft, currentRight))
+            continue;
+        if (typeof currentLeft !== typeof currentRight)
+            return false;
+        if (isPrimitive(currentLeft) || isPrimitive(currentRight))
+            return false;
+        if (!isObjectLike(currentLeft) || !isObjectLike(currentRight))
+            return false;
+        const leftObj = currentLeft;
+        const rightObj = currentRight;
+        // Cycle / aliasing consistency (bijection-ish)
+        const mappedRight = leftToRightSeen.get(leftObj);
+        if (mappedRight !== undefined) {
+            if (mappedRight !== rightObj)
+                return false;
+            continue;
+        }
+        const mappedLeft = rightToLeftSeen.get(rightObj);
+        if (mappedLeft !== undefined) {
+            if (mappedLeft !== leftObj)
+                return false;
+            continue;
+        }
+        leftToRightSeen.set(leftObj, rightObj);
+        rightToLeftSeen.set(rightObj, leftObj);
+        // Arrays: sparse holes treated as undefined
+        const leftIsArray = Array.isArray(currentLeft);
+        const rightIsArray = Array.isArray(currentRight);
+        if (leftIsArray || rightIsArray) {
+            if (!leftIsArray || !rightIsArray)
+                return false;
+            const leftArr = currentLeft;
+            const rightArr = currentRight;
+            if (leftArr.length !== rightArr.length)
+                return false;
+            for (let index = 0; index < leftArr.length; index++) {
+                const leftValue = Object.hasOwn(leftArr, index)
+                    ? leftArr[index]
+                    : undefined;
+                const rightValue = Object.hasOwn(rightArr, index)
+                    ? rightArr[index]
+                    : undefined;
+                worklist.push([leftValue, rightValue]);
+            }
+            continue;
+        }
+        // Typed arrays
+        const leftIsTypedArray = isTypedArray(currentLeft);
+        const rightIsTypedArray = isTypedArray(currentRight);
+        if (leftIsTypedArray || rightIsTypedArray) {
+            if (!leftIsTypedArray || !rightIsTypedArray)
+                return false;
+            const leftTypedArray = currentLeft;
+            const rightTypedArray = currentRight;
+            if (leftTypedArray.constructor !== rightTypedArray.constructor)
+                return false;
+            if (leftTypedArray.length !== rightTypedArray.length)
+                return false;
+            for (let index = 0; index < leftTypedArray.length; index++) {
+                if (!sameValue(leftTypedArray[index], rightTypedArray[index]))
+                    return false;
+            }
+            continue;
+        }
+        // ArrayBuffer
+        const leftIsBuffer = currentLeft instanceof ArrayBuffer;
+        const rightIsBuffer = currentRight instanceof ArrayBuffer;
+        if (leftIsBuffer || rightIsBuffer) {
+            if (!leftIsBuffer || !rightIsBuffer)
+                return false;
+            const leftBuffer = currentLeft;
+            const rightBuffer = currentRight;
+            if (leftBuffer.byteLength !== rightBuffer.byteLength)
+                return false;
+            const leftBytes = new Uint8Array(leftBuffer);
+            const rightBytes = new Uint8Array(rightBuffer);
+            for (let index = 0; index < leftBytes.length; index++) {
+                if (leftBytes[index] !== rightBytes[index])
+                    return false;
+            }
+            continue;
+        }
+        // DataView
+        const leftIsDataView = currentLeft instanceof DataView;
+        const rightIsDataView = currentRight instanceof DataView;
+        if (leftIsDataView || rightIsDataView) {
+            if (!leftIsDataView || !rightIsDataView)
+                return false;
+            const leftView = currentLeft;
+            const rightView = currentRight;
+            if (leftView.byteLength !== rightView.byteLength)
+                return false;
+            for (let offset = 0; offset < leftView.byteLength; offset++) {
+                if (leftView.getUint8(offset) !== rightView.getUint8(offset))
+                    return false;
+            }
+            continue;
+        }
+        // Date
+        const leftIsDate = currentLeft instanceof Date;
+        const rightIsDate = currentRight instanceof Date;
+        if (leftIsDate || rightIsDate) {
+            if (!leftIsDate || !rightIsDate)
+                return false;
+            if (currentLeft.getTime() !== currentRight.getTime()) {
+                return false;
+            }
+            continue;
+        }
+        // RegExp
+        const leftIsRegExp = currentLeft instanceof RegExp;
+        const rightIsRegExp = currentRight instanceof RegExp;
+        if (leftIsRegExp || rightIsRegExp) {
+            if (!leftIsRegExp || !rightIsRegExp)
+                return false;
+            const leftRe = currentLeft;
+            const rightRe = currentRight;
+            if (leftRe.source !== rightRe.source)
+                return false;
+            if (leftRe.flags !== rightRe.flags)
+                return false;
+            continue;
+        }
+        // Set (order-insensitive)
+        const leftIsSet = currentLeft instanceof Set;
+        const rightIsSet = currentRight instanceof Set;
+        if (leftIsSet || rightIsSet) {
+            if (!leftIsSet || !rightIsSet)
+                return false;
+            const leftSet = currentLeft;
+            const rightSet = currentRight;
+            if (leftSet.size !== rightSet.size)
+                return false;
+            const remainingRight = new Set(rightSet);
+            outer: for (const leftValue of leftSet) {
+                for (const rightValue of remainingRight) {
+                    if (looseEqualInternal(leftValue, rightValue, leftToRightSeen, rightToLeftSeen)) {
+                        remainingRight.delete(rightValue);
+                        continue outer;
+                    }
+                }
+                return false;
+            }
+            continue;
+        }
+        // Map (order-insensitive by entries; keys compared via looseEqual)
+        const leftIsMap = currentLeft instanceof Map;
+        const rightIsMap = currentRight instanceof Map;
+        if (leftIsMap || rightIsMap) {
+            if (!leftIsMap || !rightIsMap)
+                return false;
+            const leftMap = currentLeft;
+            const rightMap = currentRight;
+            if (leftMap.size !== rightMap.size)
+                return false;
+            const remainingRightEntries = new Set(rightMap.entries());
+            outer: for (const [leftKey, leftValue] of leftMap.entries()) {
+                for (const candidate of remainingRightEntries) {
+                    const [rightKey, rightValue] = candidate;
+                    if (looseEqualInternal(leftKey, rightKey, leftToRightSeen, rightToLeftSeen) &&
+                        looseEqualInternal(leftValue, rightValue, leftToRightSeen, rightToLeftSeen)) {
+                        remainingRightEntries.delete(candidate);
+                        continue outer;
+                    }
+                }
+                return false;
+            }
+            continue;
+        }
+        // Fallback: compare by enumerable shape (prototype-insensitive).
+        // Missing ≈ undefined via union-of-keys comparison.
+        const leftKeys = Object.keys(currentLeft);
+        const rightKeys = Object.keys(currentRight);
+        const allKeys = new Set([...leftKeys, ...rightKeys]);
+        const leftRecord = currentLeft;
+        const rightRecord = currentRight;
+        for (const key of allKeys) {
+            const leftHasKey = Object.hasOwn(leftRecord, key);
+            const rightHasKey = Object.hasOwn(rightRecord, key);
+            const leftValue = leftHasKey ? leftRecord[key] : undefined;
+            const rightValue = rightHasKey ? rightRecord[key] : undefined;
+            // If one side is missing and the other side is present-but-not-undefined, fail.
+            if (leftHasKey !== rightHasKey) {
+                if (leftValue !== undefined || rightValue !== undefined)
+                    return false;
+            }
+            worklist.push([leftValue, rightValue]);
+        }
+    }
+    return true;
+}
+export function looseEqual(left, right) {
+    if (sameValue(left, right))
+        return true;
+    if (isPrimitive(left) || isPrimitive(right))
+        return false;
+    if (!isObjectLike(left) || !isObjectLike(right))
+        return false;
+    return looseEqualInternal(left, right, new WeakMap(), new WeakMap());
+}

package/dist/esm/utils/toThrow.d.ts

@@ -0,0 +1,11 @@
+export type ToThrowExpected = undefined | string | RegExp | (new (...args: unknown[]) => Error) | {
+    message?: string | RegExp;
+    name?: string;
+};
+interface MatchResult {
+    pass: boolean;
+    message: () => string;
+}
+export declare function toThrow(received: unknown, expected?: ToThrowExpected, isNot?: boolean): MatchResult;
+export {};
+//# sourceMappingURL=toThrow.d.ts.map

package/dist/esm/utils/toThrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toThrow.d.ts","sourceRoot":"","sources":["../../../src/utils/toThrow.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GACvB,SAAS,GACT,MAAM,GACN,MAAM,GACN,CAAC,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,KAAK,CAAC,GACnC;IAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjD,UAAU,WAAW;IACnB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,MAAM,CAAC;CACvB;AAgED,wBAAgB,OAAO,CACrB,QAAQ,EAAE,OAAO,EACjB,QAAQ,CAAC,EAAE,eAAe,EAC1B,KAAK,UAAQ,GACZ,WAAW,CAgDb"}