@kensio/smartass 1.16.0 → 1.17.0

package/dist/assert/array-min-length/array-min-length.match.js

@@ -1,9 +1,15 @@
 import { createMatcher } from "../../match/match.js";
 import { repr } from "../../describe/describe.js";
+import { arrayOfMinLengthMatcher, } from "./array-min-length.type.js";
 /**
  * Matcher for an array with at least the expected minimum length.
  */
 export function arrayOfMinLength(minLength) {
-    return createMatcher((value) => Array.isArray(value) && value.length >= minLength, () => `array of at least ${repr(minLength)} elements`, () => `Array(>=${repr(minLength)})`);
+    return {
+        ...createMatcher((value) => Array.isArray(value) && value.length >= minLength, () => `array of at least ${repr(minLength)} elements`, () => `Array(>=${repr(minLength)})`),
+        // Runtime marker used only to make the matcher type nominal for type-level
+        // refinement dispatch. It is not part of the user-facing matcher behaviour.
+        [arrayOfMinLengthMatcher]: minLength,
+    };
 }
 //# sourceMappingURL=array-min-length.match.js.map

package/dist/assert/array-min-length/array-min-length.match.js.map

@@ -1 +1 @@
-{"version":3,"file":"array-min-length.match.js","sourceRoot":"","sources":["../../../src/assert/array-min-length/array-min-length.match.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC5E,OAAO,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AAoBlD;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAC9B,SAAY;IAEZ,OAAO,aAAa,CAClB,CAAC,KAAK,EAAyC,EAAE,CAC/C,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,IAAI,SAAS,EACnD,GAAG,EAAE,CAAC,qBAAqB,IAAI,CAAC,SAAS,CAAC,WAAW,EACrD,GAAG,EAAE,CAAC,WAAW,IAAI,CAAC,SAAS,CAAC,GAAG,CACpC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"array-min-length.match.js","sourceRoot":"","sources":["../../../src/assert/array-min-length/array-min-length.match.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AAClD,OAAO,EACL,uBAAuB,GAGxB,MAAM,4BAA4B,CAAC;AAEpC;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAC9B,SAAY;IAEZ,OAAO;QACL,GAAG,aAAa,CACd,CAAC,KAAK,EAAyC,EAAE,CAC/C,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,IAAI,SAAS,EACnD,GAAG,EAAE,CAAC,qBAAqB,IAAI,CAAC,SAAS,CAAC,WAAW,EACrD,GAAG,EAAE,CAAC,WAAW,IAAI,CAAC,SAAS,CAAC,GAAG,CACpC;QACD,2EAA2E;QAC3E,4EAA4E;QAC5E,CAAC,uBAAuB,CAAC,EAAE,SAAS;KACrC,CAAC;AACJ,CAAC"}

package/dist/assert/array-min-length/array-min-length.type.d.ts

@@ -0,0 +1,35 @@
+import type { AssertionMatcher, refinement } from "../../match/match.js";
+/**
+ * Unique symbol to reliably identify the ArrayOfMinLengthMatcher type.
+ *
+ * TypeScript is structurally typed, so matcher types with similar predicates
+ * can otherwise accidentally satisfy each other's conditional branches.
+ */
+export declare const arrayOfMinLengthMatcher: unique symbol;
+type ArrayElementOf<T> = T extends readonly (infer TElement)[] ? TElement : unknown;
+type ArrayMatchElement<TActual> = [
+    Extract<NonNullable<TActual>, readonly unknown[]>
+] extends [never] ? unknown : ArrayElementOf<Extract<NonNullable<TActual>, readonly unknown[]>>;
+export type ArrayOfMinLength<T, N extends number> = N extends 0 ? T[] : N extends 1 ? [T, ...T[]] : N extends 2 ? [T, T, ...T[]] : N extends 3 ? [T, T, T, ...T[]] : N extends 4 ? [T, T, T, T, ...T[]] : N extends 5 ? [T, T, T, T, T, ...T[]] : [T, T, T, T, T, ...T[]];
+/**
+ * Type produced when an actual value is matched by arrayOfMinLength().
+ *
+ * The primary goal is to expose clean, readable user-facing types in IDE
+ * tooltips and TypeScript errors. When the calling scope already knows the
+ * actual value is an array, we preserve its element type. Otherwise, we fall
+ * back to unknown elements.
+ */
+export type ArrayOfMinLengthMatch<TActual, N extends number> = ArrayOfMinLength<ArrayMatchElement<TActual>, N>;
+export type ArrayOfMinLengthMatcher<N extends number> = AssertionMatcher<ArrayOfMinLength<unknown, N>> & {
+    readonly [arrayOfMinLengthMatcher]: N;
+    /**
+     * Optional type-level hook used by compositional assertions such as
+     * assertObjectMatches().
+     *
+     * This lets the matcher describe how it refines an existing actual type,
+     * rather than only exposing the standalone matches() predicate type.
+     */
+    readonly [refinement]?: <TActual>(actual: TActual) => ArrayOfMinLengthMatch<TActual, N>;
+};
+export {};
+//# sourceMappingURL=array-min-length.type.d.ts.map

package/dist/assert/array-min-length/array-min-length.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-min-length.type.d.ts","sourceRoot":"","sources":["../../../src/assert/array-min-length/array-min-length.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEzE;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,eAEnC,CAAC;AAEF,KAAK,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,CAAC,MAAM,QAAQ,CAAC,EAAE,GAC1D,QAAQ,GACR,OAAO,CAAC;AAEZ,KAAK,iBAAiB,CAAC,OAAO,IAAI;IAChC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CAClD,SAAS,CAAC,KAAK,CAAC,GACb,OAAO,GACP,cAAc,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC,CAAC;AAEtE,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,GAC3D,CAAC,EAAE,GACH,CAAC,SAAS,CAAC,GACT,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,GACX,CAAC,SAAS,CAAC,GACT,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,GACd,CAAC,SAAS,CAAC,GACT,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,GACjB,CAAC,SAAS,CAAC,GACT,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,GACpB,CAAC,SAAS,CAAC,GACT,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,GACvB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;AAEtC;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,CAAC,OAAO,EAAE,CAAC,SAAS,MAAM,IAAI,gBAAgB,CAC7E,iBAAiB,CAAC,OAAO,CAAC,EAC1B,CAAC,CACF,CAAC;AAEF,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,MAAM,IAAI,gBAAgB,CACtE,gBAAgB,CAAC,OAAO,EAAE,CAAC,CAAC,CAC7B,GAAG;IACF,QAAQ,CAAC,CAAC,uBAAuB,CAAC,EAAE,CAAC,CAAC;IAEtC;;;;;;OAMG;IACH,QAAQ,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,OAAO,EAC9B,MAAM,EAAE,OAAO,KACZ,qBAAqB,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;CACxC,CAAC"}

package/dist/assert/array-min-length/array-min-length.type.js

@@ -0,0 +1,8 @@
+/**
+ * Unique symbol to reliably identify the ArrayOfMinLengthMatcher type.
+ *
+ * TypeScript is structurally typed, so matcher types with similar predicates
+ * can otherwise accidentally satisfy each other's conditional branches.
+ */
+export const arrayOfMinLengthMatcher = Symbol("smartass.arrayOfMinLengthMatcher");
+//# sourceMappingURL=array-min-length.type.js.map

package/dist/assert/array-min-length/array-min-length.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-min-length.type.js","sourceRoot":"","sources":["../../../src/assert/array-min-length/array-min-length.type.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,MAAM,CAC3C,kCAAkC,CACnC,CAAC"}

package/dist/assert/array-not-empty/array-not-empty.assert.d.ts

@@ -1,6 +1,4 @@
-import { type NonEmptyArray } from "./array-not-empty.match.js";
-/**
- * Assert that an array has at least one element, with type-narrowing.
- */
-export declare function assertArrayNotEmpty<T>(value: readonly T[] | undefined | null, message?: string): asserts value is NonEmptyArray<T>;
+import type { NonEmptyArray } from "./array-not-empty.type.js";
+export declare function assertArrayNotEmpty<TArray extends unknown[]>(value: TArray, message?: string): asserts value is TArray & NonEmptyArray<TArray[number]>;
+export declare function assertArrayNotEmpty(value: unknown, message?: string): asserts value is NonEmptyArray<unknown>;
 //# sourceMappingURL=array-not-empty.assert.d.ts.map

package/dist/assert/array-not-empty/array-not-empty.assert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array-not-empty.assert.d.ts","sourceRoot":"","sources":["../../../src/assert/array-not-empty/array-not-empty.assert.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,4BAA4B,CAAC;AAG/E;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,SAAS,GAAG,IAAI,EACtC,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,KAAK,IAAI,aAAa,CAAC,CAAC,CAAC,CAUnC"}
+{"version":3,"file":"array-not-empty.assert.d.ts","sourceRoot":"","sources":["../../../src/assert/array-not-empty/array-not-empty.assert.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE/D,wBAAgB,mBAAmB,CAAC,MAAM,SAAS,OAAO,EAAE,EAC1D,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,KAAK,IAAI,MAAM,GAAG,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;AAE3D,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,KAAK,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC"}

package/dist/assert/array-not-empty/array-not-empty.assert.js

@@ -1,13 +1,18 @@
-import { assertNonNullable } from "../non-nullable/non-nullable.assert.js";
 import { nonEmptyArray } from "./array-not-empty.match.js";
 import { AssertionError } from "../../assertion-error.js";
+import { desc } from "../../describe/describe.js";
 /**
  * Assert that an array has at least one element, with type-narrowing.
  */
 export function assertArrayNotEmpty(value, message) {
-    assertNonNullable(value, message);
     if (!nonEmptyArray().matches(value)) {
-        throw new AssertionError(message ?? `Expected array not to be empty, but it was empty.`, value, ["..."]);
+        throw new AssertionError(message ?? buildArrayNotEmptyMessage(value), value, ["..."]);
     }
 }
+function buildArrayNotEmptyMessage(value) {
+    if (!Array.isArray(value)) {
+        return `Expected ${desc(value)} to be a non-empty array.`;
+    }
+    return `Expected array not to be empty, but it was empty.`;
+}
 //# sourceMappingURL=array-not-empty.assert.js.map

package/dist/assert/array-not-empty/array-not-empty.assert.js.map

@@ -1 +1 @@
-{"version":3,"file":"array-not-empty.assert.js","sourceRoot":"","sources":["../../../src/assert/array-not-empty/array-not-empty.assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAsB,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC/E,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE1D;;GAEG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAAsC,EACtC,OAAgB;IAEhB,iBAAiB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAElC,IAAI,CAAC,aAAa,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACpC,MAAM,IAAI,cAAc,CACtB,OAAO,IAAI,mDAAmD,EAC9D,KAAK,EACL,CAAC,KAAK,CAAC,CACR,CAAC;IACJ,CAAC;AACH,CAAC"}
+{"version":3,"file":"array-not-empty.assert.js","sourceRoot":"","sources":["../../../src/assert/array-not-empty/array-not-empty.assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AAalD;;GAEG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAc,EAAE,OAAgB;IAClE,IAAI,CAAC,aAAa,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACpC,MAAM,IAAI,cAAc,CACtB,OAAO,IAAI,yBAAyB,CAAC,KAAK,CAAC,EAC3C,KAAK,EACL,CAAC,KAAK,CAAC,CACR,CAAC;IACJ,CAAC;AACH,CAAC;AAED,SAAS,yBAAyB,CAAC,KAAc;IAC/C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,YAAY,IAAI,CAAC,KAAK,CAAC,2BAA2B,CAAC;IAC5D,CAAC;IAED,OAAO,mDAAmD,CAAC;AAC7D,CAAC"}

package/dist/assert/array-not-empty/array-not-empty.match.d.ts

@@ -1,6 +1,4 @@
-import { type AssertionMatcher } from "../../match/match.js";
-export type NonEmptyArray<T> = readonly [T, ...T[]];
-export type NonEmptyArrayMatcher = AssertionMatcher<NonEmptyArray<unknown>>;
+import { type NonEmptyArrayMatcher } from "./array-not-empty.type.js";
 /**
  * Matcher for a non-empty array.
  */

package/dist/assert/array-not-empty/array-not-empty.match.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array-not-empty.match.d.ts","sourceRoot":"","sources":["../../../src/assert/array-not-empty/array-not-empty.match.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAiB,MAAM,sBAAsB,CAAC;AAE5E,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;AAEpD,MAAM,MAAM,oBAAoB,GAAG,gBAAgB,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;AAE5E;;GAEG;AACH,wBAAgB,aAAa,IAAI,oBAAoB,CAOpD"}
+{"version":3,"file":"array-not-empty.match.d.ts","sourceRoot":"","sources":["../../../src/assert/array-not-empty/array-not-empty.match.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,2BAA2B,CAAC;AAEnC;;GAEG;AACH,wBAAgB,aAAa,IAAI,oBAAoB,CAYpD"}

package/dist/assert/array-not-empty/array-not-empty.match.js

@@ -1,8 +1,14 @@
 import { createMatcher } from "../../match/match.js";
+import { nonEmptyArrayMatcher, } from "./array-not-empty.type.js";
 /**
  * Matcher for a non-empty array.
  */
 export function nonEmptyArray() {
-    return createMatcher((value) => Array.isArray(value) && value.length > 0, () => `non-empty array`, () => `[…]`);
+    return {
+        ...createMatcher((value) => Array.isArray(value) && value.length > 0, () => `non-empty array`, () => `[…]`),
+        // Runtime marker used only to make the matcher type nominal for type-level
+        // refinement dispatch. It is not part of the user-facing matcher behaviour.
+        [nonEmptyArrayMatcher]: true,
+    };
 }
 //# sourceMappingURL=array-not-empty.match.js.map

package/dist/assert/array-not-empty/array-not-empty.match.js.map

@@ -1 +1 @@
-{"version":3,"file":"array-not-empty.match.js","sourceRoot":"","sources":["../../../src/assert/array-not-empty/array-not-empty.match.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAM5E;;GAEG;AACH,MAAM,UAAU,aAAa;IAC3B,OAAO,aAAa,CAClB,CAAC,KAAK,EAAmC,EAAE,CACzC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAC1C,GAAG,EAAE,CAAC,iBAAiB,EACvB,GAAG,EAAE,CAAC,KAAK,CACZ,CAAC;AACJ,CAAC"}
+{"version":3,"file":"array-not-empty.match.js","sourceRoot":"","sources":["../../../src/assert/array-not-empty/array-not-empty.match.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EACL,oBAAoB,GAGrB,MAAM,2BAA2B,CAAC;AAEnC;;GAEG;AACH,MAAM,UAAU,aAAa;IAC3B,OAAO;QACL,GAAG,aAAa,CACd,CAAC,KAAK,EAAmC,EAAE,CACzC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAC1C,GAAG,EAAE,CAAC,iBAAiB,EACvB,GAAG,EAAE,CAAC,KAAK,CACZ;QACD,2EAA2E;QAC3E,4EAA4E;QAC5E,CAAC,oBAAoB,CAAC,EAAE,IAAI;KAC7B,CAAC;AACJ,CAAC"}

package/dist/assert/array-not-empty/array-not-empty.type.d.ts

@@ -0,0 +1,35 @@
+import type { AssertionMatcher, refinement } from "../../match/match.js";
+/**
+ * Unique symbol to reliably identify the NonEmptyArrayMatcher type.
+ *
+ * TypeScript is structurally typed, so matcher types with similar predicates
+ * can otherwise accidentally satisfy each other's conditional branches.
+ */
+export declare const nonEmptyArrayMatcher: unique symbol;
+type ArrayElementOf<T> = T extends readonly (infer TElement)[] ? TElement : unknown;
+type ArrayMatchElement<TActual> = [
+    Extract<NonNullable<TActual>, readonly unknown[]>
+] extends [never] ? unknown : ArrayElementOf<Extract<NonNullable<TActual>, readonly unknown[]>>;
+export type NonEmptyArray<T> = [T, ...T[]];
+/**
+ * Type produced when an actual value is matched by nonEmptyArray().
+ *
+ * The primary goal is to expose clean, readable user-facing types in IDE
+ * tooltips and TypeScript errors. When the calling scope already knows the
+ * actual value is an array, we preserve its element type. Otherwise, we fall
+ * back to unknown elements.
+ */
+export type NonEmptyArrayMatch<TActual> = NonEmptyArray<ArrayMatchElement<TActual>>;
+export type NonEmptyArrayMatcher = AssertionMatcher<NonEmptyArray<unknown>> & {
+    readonly [nonEmptyArrayMatcher]: true;
+    /**
+     * Optional type-level hook used by compositional assertions such as
+     * assertObjectMatches().
+     *
+     * This lets the matcher describe how it refines an existing actual type,
+     * rather than only exposing the standalone matches() predicate type.
+     */
+    readonly [refinement]?: <TActual>(actual: TActual) => NonEmptyArrayMatch<TActual>;
+};
+export {};
+//# sourceMappingURL=array-not-empty.type.d.ts.map

package/dist/assert/array-not-empty/array-not-empty.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-not-empty.type.d.ts","sourceRoot":"","sources":["../../../src/assert/array-not-empty/array-not-empty.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEzE;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,eAA0C,CAAC;AAE5E,KAAK,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,CAAC,MAAM,QAAQ,CAAC,EAAE,GAC1D,QAAQ,GACR,OAAO,CAAC;AAEZ,KAAK,iBAAiB,CAAC,OAAO,IAAI;IAChC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CAClD,SAAS,CAAC,KAAK,CAAC,GACb,OAAO,GACP,cAAc,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC,CAAC;AAEtE,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;AAE3C;;;;;;;GAOG;AACH,MAAM,MAAM,kBAAkB,CAAC,OAAO,IAAI,aAAa,CACrD,iBAAiB,CAAC,OAAO,CAAC,CAC3B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,gBAAgB,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,GAAG;IAC5E,QAAQ,CAAC,CAAC,oBAAoB,CAAC,EAAE,IAAI,CAAC;IAEtC;;;;;;OAMG;IACH,QAAQ,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,OAAO,EAC9B,MAAM,EAAE,OAAO,KACZ,kBAAkB,CAAC,OAAO,CAAC,CAAC;CAClC,CAAC"}

package/dist/assert/array-not-empty/array-not-empty.type.js

@@ -0,0 +1,8 @@
+/**
+ * Unique symbol to reliably identify the NonEmptyArrayMatcher type.
+ *
+ * TypeScript is structurally typed, so matcher types with similar predicates
+ * can otherwise accidentally satisfy each other's conditional branches.
+ */
+export const nonEmptyArrayMatcher = Symbol("smartass.nonEmptyArrayMatcher");
+//# sourceMappingURL=array-not-empty.type.js.map

package/dist/assert/array-not-empty/array-not-empty.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-not-empty.type.js","sourceRoot":"","sources":["../../../src/assert/array-not-empty/array-not-empty.type.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC,+BAA+B,CAAC,CAAC"}

package/dist/assert/buffer-equal/buffer-equal.assert.d.ts

@@ -1,4 +1,4 @@
-import type { TypedArray } from "../type-typed-array/type-typed-array.match.js";
+import type { TypedArray } from "../type-typed-array/type-typed-array.type.js";
 /**
  * Assert that two buffers (TypedArrays) are equal, comparing element by element.
  * Supports all TypedArray types: Uint8Array, Int8Array, Uint16Array, Int16Array,

package/dist/assert/buffer-equal/buffer-equal.assert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buffer-equal.assert.d.ts","sourceRoot":"","sources":["../../../src/assert/buffer-equal/buffer-equal.assert.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+CAA+C,CAAC;AAEhF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,UAAU,EACpD,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,CAAC,EACX,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,IAAI,CAAC,CAQrB"}
+{"version":3,"file":"buffer-equal.assert.d.ts","sourceRoot":"","sources":["../../../src/assert/buffer-equal/buffer-equal.assert.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8CAA8C,CAAC;AAE/E;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,UAAU,EACpD,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,CAAC,EACX,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,IAAI,CAAC,CAQrB"}

package/dist/assert/buffer-equal/buffer-equal.assert.js.map

@@ -1 +1 @@
-{"version":3,"file":"buffer-equal.assert.js","sourceRoot":"","sources":["../../../src/assert/buffer-equal/buffer-equal.assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAGxD;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAAe,EACf,QAAW,EACX,OAAgB;IAEhB,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7C,MAAM,IAAI,cAAc,CACtB,OAAO,IAAI,YAAY,IAAI,CAAC,MAAM,CAAC,aAAa,IAAI,CAAC,QAAQ,CAAC,GAAG,EACjE,MAAM,EACN,QAAQ,CACT,CAAC;IACJ,CAAC;AACH,CAAC"}
+{"version":3,"file":"buffer-equal.assert.js","sourceRoot":"","sources":["../../../src/assert/buffer-equal/buffer-equal.assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAIxD;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAAe,EACf,QAAW,EACX,OAAgB;IAEhB,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7C,MAAM,IAAI,cAAc,CACtB,OAAO,IAAI,YAAY,IAAI,CAAC,MAAM,CAAC,aAAa,IAAI,CAAC,QAAQ,CAAC,GAAG,EACjE,MAAM,EACN,QAAQ,CACT,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/assert/buffer-equal/buffer-equal.match.d.ts

@@ -1,7 +1,7 @@
-import { type AssertionMatcher } from "../../match/match.js";
-import type { TypedArray } from "../type-typed-array/type-typed-array.match.js";
+import { type BufferEqualToMatcher } from "./buffer-equal.type.js";
+import type { TypedArray } from "../type-typed-array/type-typed-array.type.js";
 /**
  * Matcher for a TypedArray equal to an expected TypedArray, comparing byte by byte.
  */
-export declare function bufferEqualTo<T extends TypedArray>(expected: T): AssertionMatcher<T>;
+export declare function bufferEqualTo<T extends TypedArray>(expected: T): BufferEqualToMatcher<T>;
 //# sourceMappingURL=buffer-equal.match.d.ts.map

package/dist/assert/buffer-equal/buffer-equal.match.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buffer-equal.match.d.ts","sourceRoot":"","sources":["../../../src/assert/buffer-equal/buffer-equal.match.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE5E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+CAA+C,CAAC;AAEhF;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,UAAU,EAChD,QAAQ,EAAE,CAAC,GACV,gBAAgB,CAAC,CAAC,CAAC,CAyBrB"}
+{"version":3,"file":"buffer-equal.match.d.ts","sourceRoot":"","sources":["../../../src/assert/buffer-equal/buffer-equal.match.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8CAA8C,CAAC;AAE/E;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,UAAU,EAChD,QAAQ,EAAE,CAAC,GACV,oBAAoB,CAAC,CAAC,CAAC,CAkCzB"}

package/dist/assert/buffer-equal/buffer-equal.match.js

@@ -1,20 +1,29 @@
 import { desc, repr } from "../../describe/describe.js";
 import { createMatcher } from "../../match/match.js";
 import { assertTypeTypedArray } from "../type-typed-array/type-typed-array.assert.js";
+import { bufferEqualToMatcher, } from "./buffer-equal.type.js";
 /**
  * Matcher for a TypedArray equal to an expected TypedArray, comparing byte by byte.
  */
 export function bufferEqualTo(expected) {
-    return createMatcher((value) => {
-        try {
-            assertTypeTypedArray(value);
-        }
-        catch {
-            return false;
-        }
-        const actualBuffer = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
-        const expectedBuffer = Buffer.from(expected.buffer, expected.byteOffset, expected.byteLength);
-        return Buffer.compare(actualBuffer, expectedBuffer) === 0;
-    }, () => `buffer equal to ${desc(expected)}`, () => repr(expected));
+    return {
+        ...createMatcher((value) => {
+            try {
+                assertTypeTypedArray(value);
+            }
+            catch {
+                return false;
+            }
+            if (value.constructor !== expected.constructor) {
+                return false;
+            }
+            const actualBuffer = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+            const expectedBuffer = Buffer.from(expected.buffer, expected.byteOffset, expected.byteLength);
+            return Buffer.compare(actualBuffer, expectedBuffer) === 0;
+        }, () => `buffer equal to ${desc(expected)}`, () => repr(expected)),
+        // Runtime marker used only to make the matcher type nominal for type-level
+        // refinement dispatch. It is not part of the user-facing matcher behaviour.
+        [bufferEqualToMatcher]: expected,
+    };
 }
 //# sourceMappingURL=buffer-equal.match.js.map

package/dist/assert/buffer-equal/buffer-equal.match.js.map

@@ -1 +1 @@
-{"version":3,"file":"buffer-equal.match.js","sourceRoot":"","sources":["../../../src/assert/buffer-equal/buffer-equal.match.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,EAAE,aAAa,EAAyB,MAAM,sBAAsB,CAAC;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,gDAAgD,CAAC;AAGtF;;GAEG;AACH,MAAM,UAAU,aAAa,CAC3B,QAAW;IAEX,OAAO,aAAa,CAClB,CAAC,KAAK,EAAc,EAAE;QACpB,IAAI,CAAC;YACH,oBAAoB,CAAC,KAAK,CAAC,CAAC;QAC9B,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,YAAY,GAAG,MAAM,CAAC,IAAI,CAC9B,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,UAAU,CACjB,CAAC;QACF,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAChC,QAAQ,CAAC,MAAM,EACf,QAAQ,CAAC,UAAU,EACnB,QAAQ,CAAC,UAAU,CACpB,CAAC;QAEF,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC;IAC5D,CAAC,EACD,GAAG,EAAE,CAAC,mBAAmB,IAAI,CAAC,QAAQ,CAAC,EAAE,EACzC,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CACrB,CAAC;AACJ,CAAC"}
+{"version":3,"file":"buffer-equal.match.js","sourceRoot":"","sources":["../../../src/assert/buffer-equal/buffer-equal.match.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gDAAgD,CAAC;AACtF,OAAO,EACL,oBAAoB,GAErB,MAAM,wBAAwB,CAAC;AAIhC;;GAEG;AACH,MAAM,UAAU,aAAa,CAC3B,QAAW;IAEX,OAAO;QACL,GAAG,aAAa,CACd,CAAC,KAAK,EAAc,EAAE;YACpB,IAAI,CAAC;gBACH,oBAAoB,CAAC,KAAK,CAAC,CAAC;YAC9B,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,KAAK,CAAC;YACf,CAAC;YAED,IAAI,KAAK,CAAC,WAAW,KAAK,QAAQ,CAAC,WAAW,EAAE,CAAC;gBAC/C,OAAO,KAAK,CAAC;YACf,CAAC;YAED,MAAM,YAAY,GAAG,MAAM,CAAC,IAAI,CAC9B,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,UAAU,CACjB,CAAC;YACF,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAChC,QAAQ,CAAC,MAAM,EACf,QAAQ,CAAC,UAAU,EACnB,QAAQ,CAAC,UAAU,CACpB,CAAC;YAEF,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC;QAC5D,CAAC,EACD,GAAG,EAAE,CAAC,mBAAmB,IAAI,CAAC,QAAQ,CAAC,EAAE,EACzC,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CACrB;QACD,2EAA2E;QAC3E,4EAA4E;QAC5E,CAAC,oBAAoB,CAAC,EAAE,QAAQ;KACjC,CAAC;AACJ,CAAC"}

package/dist/assert/buffer-equal/buffer-equal.type.d.ts

@@ -0,0 +1,32 @@
+import type { AssertionMatcher, refinement } from "../../match/match.js";
+import type { TypedArray } from "../type-typed-array/type-typed-array.type.js";
+/**
+ * Unique symbol to reliably identify the BufferEqualToMatcher type.
+ *
+ * TypeScript is structurally typed, so matcher types with similar predicates
+ * can otherwise accidentally satisfy each other's conditional branches.
+ */
+export declare const bufferEqualToMatcher: unique symbol;
+/**
+ * Type produced when an actual value is matched by bufferEqualTo().
+ *
+ * The primary goal is to expose clean, readable user-facing types in IDE
+ * tooltips and TypeScript errors. When the calling scope already has overlap
+ * with the expected TypedArray type, we preserve that overlap. Otherwise, we
+ * fall back to the expected TypedArray type.
+ */
+export type BufferEqualToMatch<TActual, TExpected extends TypedArray> = [
+    Extract<NonNullable<TActual>, TExpected>
+] extends [never] ? TExpected : Extract<NonNullable<TActual>, TExpected>;
+export type BufferEqualToMatcher<TExpected extends TypedArray> = AssertionMatcher<TExpected> & {
+    readonly [bufferEqualToMatcher]: TExpected;
+    /**
+     * Optional type-level hook used by compositional assertions such as
+     * assertObjectMatches().
+     *
+     * This lets the matcher describe how it refines an existing actual type,
+     * rather than only exposing the standalone matches() predicate type.
+     */
+    readonly [refinement]?: <TActual>(actual: TActual) => BufferEqualToMatch<TActual, TExpected>;
+};
+//# sourceMappingURL=buffer-equal.type.d.ts.map

package/dist/assert/buffer-equal/buffer-equal.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-equal.type.d.ts","sourceRoot":"","sources":["../../../src/assert/buffer-equal/buffer-equal.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8CAA8C,CAAC;AAE/E;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,eAA0C,CAAC;AAE5E;;;;;;;GAOG;AACH,MAAM,MAAM,kBAAkB,CAAC,OAAO,EAAE,SAAS,SAAS,UAAU,IAAI;IACtE,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC;CACzC,SAAS,CAAC,KAAK,CAAC,GACb,SAAS,GACT,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,CAAC;AAE7C,MAAM,MAAM,oBAAoB,CAAC,SAAS,SAAS,UAAU,IAC3D,gBAAgB,CAAC,SAAS,CAAC,GAAG;IAC5B,QAAQ,CAAC,CAAC,oBAAoB,CAAC,EAAE,SAAS,CAAC;IAE3C;;;;;;OAMG;IACH,QAAQ,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,OAAO,EAC9B,MAAM,EAAE,OAAO,KACZ,kBAAkB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;CAC7C,CAAC"}

package/dist/assert/buffer-equal/buffer-equal.type.js

@@ -0,0 +1,8 @@
+/**
+ * Unique symbol to reliably identify the BufferEqualToMatcher type.
+ *
+ * TypeScript is structurally typed, so matcher types with similar predicates
+ * can otherwise accidentally satisfy each other's conditional branches.
+ */
+export const bufferEqualToMatcher = Symbol("smartass.bufferEqualToMatcher");
+//# sourceMappingURL=buffer-equal.type.js.map

package/dist/assert/buffer-equal/buffer-equal.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-equal.type.js","sourceRoot":"","sources":["../../../src/assert/buffer-equal/buffer-equal.type.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC,+BAA+B,CAAC,CAAC"}

package/dist/assert/identical/identical.assert.d.ts

@@ -2,5 +2,5 @@
  * Assert that a value is strictly identical to an expected value using ===,
  * with type-narrowing.
  */
-export declare function assertIdentical<const TExpected>(value: unknown, expected: TExpected, message?: string): asserts value is typeof expected;
+export declare function assertIdentical<const TExpected>(value: unknown, expected: TExpected, message?: string): asserts value is TExpected;
 //# sourceMappingURL=identical.assert.d.ts.map

package/dist/assert/identical/identical.assert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"identical.assert.d.ts","sourceRoot":"","sources":["../../../src/assert/identical/identical.assert.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,CAAC,SAAS,EAC7C,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,SAAS,EACnB,OAAO,SAAkE,GACxE,OAAO,CAAC,KAAK,IAAI,OAAO,QAAQ,CAIlC"}
+{"version":3,"file":"identical.assert.d.ts","sourceRoot":"","sources":["../../../src/assert/identical/identical.assert.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,CAAC,SAAS,EAC7C,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,SAAS,EACnB,OAAO,SAAkE,GACxE,OAAO,CAAC,KAAK,IAAI,SAAS,CAI5B"}

package/dist/assert/instance-of/instance-of.assert.d.ts

@@ -1,6 +1,4 @@
-import { type InstanceOfConstructor } from "./instance-of.match.js";
-/**
- * Assertion function that checks if a value is an instance of a given class, with type-narrowing.
- */
-export declare function assertInstanceOf<const TConstructor extends abstract new (...arguments_: never[]) => object>(value: unknown, classConstructor: TConstructor, message?: string): asserts value is InstanceOfConstructor<TConstructor>;
+import type { ClassConstructor, InstanceOfAssertion } from "./instance-of.type.js";
+export declare function assertInstanceOf<TActual, TInstance>(value: TActual, classConstructor: ClassConstructor<TInstance>, message?: string): asserts value is InstanceOfAssertion<TActual, TInstance>;
+export declare function assertInstanceOf<TInstance>(value: unknown, classConstructor: ClassConstructor<TInstance>, message?: string): asserts value is TInstance;
 //# sourceMappingURL=instance-of.assert.d.ts.map

package/dist/assert/instance-of/instance-of.assert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instance-of.assert.d.ts","sourceRoot":"","sources":["../../../src/assert/instance-of/instance-of.assert.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAEhF;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,CAAC,YAAY,SAAS,QAAQ,MAAM,GAAG,UAAU,EAAE,KAAK,EAAE,KAAK,MAAM,EAE1E,KAAK,EAAE,OAAO,EACd,gBAAgB,EAAE,YAAY,EAC9B,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,KAAK,IAAI,qBAAqB,CAAC,YAAY,CAAC,CAStD"}
+{"version":3,"file":"instance-of.assert.d.ts","sourceRoot":"","sources":["../../../src/assert/instance-of/instance-of.assert.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,uBAAuB,CAAC;AAE/B,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,EACjD,KAAK,EAAE,OAAO,EACd,gBAAgB,EAAE,gBAAgB,CAAC,SAAS,CAAC,EAC7C,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,KAAK,IAAI,mBAAmB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;AAE5D,wBAAgB,gBAAgB,CAAC,SAAS,EACxC,KAAK,EAAE,OAAO,EACd,gBAAgB,EAAE,gBAAgB,CAAC,SAAS,CAAC,EAC7C,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,KAAK,IAAI,SAAS,CAAC"}

package/dist/assert/instance-of/instance-of.assert.js.map

@@ -1 +1 @@
-{"version":3,"file":"instance-of.assert.js","sourceRoot":"","sources":["../../../src/assert/instance-of/instance-of.assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,UAAU,EAA8B,MAAM,wBAAwB,CAAC;AAEhF;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAG9B,KAAc,EACd,gBAA8B,EAC9B,OAAgB;IAEhB,MAAM,OAAO,GAAG,UAAU,CAAC,gBAAgB,CAAC,CAAC;IAC7C,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,cAAc,CACtB,OAAO,IAAI,wBAAwB,OAAO,CAAC,QAAQ,EAAE,mBAAmB,EACxE,KAAK,EACL,OAAO,CAAC,SAAS,EAAE,CACpB,CAAC;IACJ,CAAC;AACH,CAAC"}
+{"version":3,"file":"instance-of.assert.js","sourceRoot":"","sources":["../../../src/assert/instance-of/instance-of.assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAkBpD;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAC9B,KAAc,EACd,gBAA6C,EAC7C,OAAgB;IAEhB,MAAM,OAAO,GAAG,UAAU,CAAC,gBAAgB,CAAC,CAAC;IAC7C,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,cAAc,CACtB,OAAO,IAAI,wBAAwB,OAAO,CAAC,QAAQ,EAAE,mBAAmB,EACxE,KAAK,EACL,OAAO,CAAC,SAAS,EAAE,CACpB,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/assert/instance-of/instance-of.match.d.ts

@@ -1,7 +1,6 @@
-import { type AssertionMatcher } from "../../match/match.js";
-export type InstanceOfConstructor<TConstructor> = TConstructor extends abstract new (...arguments_: never[]) => infer TInstance ? TInstance : never;
+import { type ClassConstructor, type InstanceOfMatcher } from "./instance-of.type.js";
 /**
  * Matcher for a value being an instance of a given class.
  */
-export declare function instanceOf<const TConstructor extends abstract new (...arguments_: never[]) => object>(classConstructor: TConstructor): AssertionMatcher<InstanceOfConstructor<TConstructor>>;
+export declare function instanceOf<T>(classConstructor: ClassConstructor<T>): InstanceOfMatcher<T>;
 //# sourceMappingURL=instance-of.match.d.ts.map

package/dist/assert/instance-of/instance-of.match.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instance-of.match.d.ts","sourceRoot":"","sources":["../../../src/assert/instance-of/instance-of.match.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAiB,MAAM,sBAAsB,CAAC;AAE5E,MAAM,MAAM,qBAAqB,CAAC,YAAY,IAC5C,YAAY,SAAS,QAAQ,MAAM,GAAG,UAAU,EAAE,KAAK,EAAE,KAAK,MAAM,SAAS,GACzE,SAAS,GACT,KAAK,CAAC;AAEZ;;GAEG;AACH,wBAAgB,UAAU,CACxB,KAAK,CAAC,YAAY,SAAS,QAAQ,MAAM,GAAG,UAAU,EAAE,KAAK,EAAE,KAAK,MAAM,EAE1E,gBAAgB,EAAE,YAAY,GAC7B,gBAAgB,CAAC,qBAAqB,CAAC,YAAY,CAAC,CAAC,CAOvD"}
+{"version":3,"file":"instance-of.match.d.ts","sourceRoot":"","sources":["../../../src/assert/instance-of/instance-of.match.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACvB,MAAM,uBAAuB,CAAC;AAE/B;;GAEG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAC1B,gBAAgB,EAAE,gBAAgB,CAAC,CAAC,CAAC,GACpC,iBAAiB,CAAC,CAAC,CAAC,CAWtB"}

package/dist/assert/instance-of/instance-of.match.js

@@ -1,8 +1,14 @@
 import { createMatcher } from "../../match/match.js";
+import { instanceOfMatcher, } from "./instance-of.type.js";
 /**
  * Matcher for a value being an instance of a given class.
  */
 export function instanceOf(classConstructor) {
-    return createMatcher((value) => value instanceof classConstructor, () => `instance of ${classConstructor.name}`, () => `${classConstructor.name}()`);
+    return {
+        ...createMatcher((value) => value instanceof classConstructor, () => `instance of ${classConstructor.name}`, () => `${classConstructor.name}()`),
+        // Runtime marker used only to make the matcher type nominal for type-level
+        // refinement dispatch. It is not part of the user-facing matcher behaviour.
+        [instanceOfMatcher]: undefined,
+    };
 }
 //# sourceMappingURL=instance-of.match.js.map

package/dist/assert/instance-of/instance-of.match.js.map

@@ -1 +1 @@
-{"version":3,"file":"instance-of.match.js","sourceRoot":"","sources":["../../../src/assert/instance-of/instance-of.match.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAO5E;;GAEG;AACH,MAAM,UAAU,UAAU,CAGxB,gBAA8B;IAE9B,OAAO,aAAa,CAClB,CAAC,KAAK,EAAgD,EAAE,CACtD,KAAK,YAAY,gBAAgB,EACnC,GAAG,EAAE,CAAC,eAAe,gBAAgB,CAAC,IAAI,EAAE,EAC5C,GAAG,EAAE,CAAC,GAAG,gBAAgB,CAAC,IAAI,IAAI,CACnC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"instance-of.match.js","sourceRoot":"","sources":["../../../src/assert/instance-of/instance-of.match.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EACL,iBAAiB,GAGlB,MAAM,uBAAuB,CAAC;AAE/B;;GAEG;AACH,MAAM,UAAU,UAAU,CACxB,gBAAqC;IAErC,OAAO;QACL,GAAG,aAAa,CACd,CAAC,KAAK,EAAc,EAAE,CAAC,KAAK,YAAY,gBAAgB,EACxD,GAAG,EAAE,CAAC,eAAe,gBAAgB,CAAC,IAAI,EAAE,EAC5C,GAAG,EAAE,CAAC,GAAG,gBAAgB,CAAC,IAAI,IAAI,CACnC;QACD,2EAA2E;QAC3E,4EAA4E;QAC5E,CAAC,iBAAiB,CAAC,EAAE,SAAc;KACpC,CAAC;AACJ,CAAC"}

package/dist/assert/instance-of/instance-of.type.d.ts

@@ -0,0 +1,42 @@
+import type { AssertionMatcher, refinement } from "../../match/match.js";
+/**
+ * Unique symbol to reliably identify the InstanceOfMatcher type.
+ *
+ * TypeScript is structurally typed, so matcher types with similar predicates
+ * can otherwise accidentally satisfy each other's conditional branches.
+ */
+export declare const instanceOfMatcher: unique symbol;
+export type ClassConstructor<T> = abstract new (...args: never[]) => T;
+/**
+ * Type produced when an actual value is matched by instanceOf().
+ *
+ * The primary goal is to expose clean, readable user-facing types in IDE
+ * tooltips and TypeScript errors. When the calling scope already has overlap
+ * with the expected instance type, we preserve that overlap. Otherwise, we fall
+ * back to the expected instance type.
+ */
+export type InstanceOfMatch<TActual, TInstance> = [
+    Extract<NonNullable<TActual>, TInstance>
+] extends [never] ? TInstance : Extract<NonNullable<TActual>, TInstance>;
+/**
+ * Type produced when assertInstanceOf() narrows a value.
+ *
+ * Assertion functions must assert a type assignable to the asserted parameter's
+ * original type. So unlike InstanceOfMatch, the no-overlap fallback keeps the
+ * original actual type in an intersection.
+ */
+export type InstanceOfAssertion<TActual, TInstance> = [
+    Extract<NonNullable<TActual>, TInstance>
+] extends [never] ? TActual & TInstance : Extract<NonNullable<TActual>, TInstance>;
+export type InstanceOfMatcher<T> = AssertionMatcher<T> & {
+    readonly [instanceOfMatcher]: T;
+    /**
+     * Optional type-level hook used by compositional assertions such as
+     * assertObjectMatches().
+     *
+     * This lets the matcher describe how it refines an existing actual type,
+     * rather than only exposing the standalone matches() predicate type.
+     */
+    readonly [refinement]?: <TActual>(actual: TActual) => InstanceOfMatch<TActual, T>;
+};
+//# sourceMappingURL=instance-of.type.d.ts.map

package/dist/assert/instance-of/instance-of.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-of.type.d.ts","sourceRoot":"","sources":["../../../src/assert/instance-of/instance-of.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEzE;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,eAAuC,CAAC;AAEtE,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,QAAQ,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AAEvE;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,CAAC,OAAO,EAAE,SAAS,IAAI;IAChD,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC;CACzC,SAAS,CAAC,KAAK,CAAC,GACb,SAAS,GACT,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,CAAC;AAE7C;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,CAAC,OAAO,EAAE,SAAS,IAAI;IACpD,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC;CACzC,SAAS,CAAC,KAAK,CAAC,GACb,OAAO,GAAG,SAAS,GACnB,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,CAAC;AAE7C,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC,GAAG;IACvD,QAAQ,CAAC,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;IAEhC;;;;;;OAMG;IACH,QAAQ,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,OAAO,EAC9B,MAAM,EAAE,OAAO,KACZ,eAAe,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;CAClC,CAAC"}

package/dist/assert/instance-of/instance-of.type.js

@@ -0,0 +1,8 @@
+/**
+ * Unique symbol to reliably identify the InstanceOfMatcher type.
+ *
+ * TypeScript is structurally typed, so matcher types with similar predicates
+ * can otherwise accidentally satisfy each other's conditional branches.
+ */
+export const instanceOfMatcher = Symbol("smartass.instanceOfMatcher");
+//# sourceMappingURL=instance-of.type.js.map

package/dist/assert/instance-of/instance-of.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-of.type.js","sourceRoot":"","sources":["../../../src/assert/instance-of/instance-of.type.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC,4BAA4B,CAAC,CAAC"}

package/dist/assert/map-size/map-size.assert.d.ts

@@ -0,0 +1,4 @@
+import type { MapOfSize, MapOfSizeMatch } from "./map-size.type.js";
+export declare function assertMapSize<TMap extends Map<unknown, unknown>, const N extends number>(value: TMap, expectedSize: N, message?: string): asserts value is TMap & MapOfSizeMatch<TMap, N>;
+export declare function assertMapSize<const N extends number>(value: unknown, expectedSize: N, message?: string): asserts value is MapOfSize<unknown, unknown, N>;
+//# sourceMappingURL=map-size.assert.d.ts.map

package/dist/assert/map-size/map-size.assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-size.assert.d.ts","sourceRoot":"","sources":["../../../src/assert/map-size/map-size.assert.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpE,wBAAgB,aAAa,CAC3B,IAAI,SAAS,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,EAClC,KAAK,CAAC,CAAC,SAAS,MAAM,EAEtB,KAAK,EAAE,IAAI,EACX,YAAY,EAAE,CAAC,EACf,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,KAAK,IAAI,IAAI,GAAG,cAAc,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AAEnD,wBAAgB,aAAa,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,EAClD,KAAK,EAAE,OAAO,EACd,YAAY,EAAE,CAAC,EACf,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,KAAK,IAAI,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC"}

package/dist/assert/map-size/map-size.assert.js

@@ -0,0 +1,19 @@
+import { AssertionError } from "../../assertion-error.js";
+import { desc, repr } from "../../describe/describe.js";
+import { mapOfSize } from "./map-size.match.js";
+/**
+ * Assert that a Map has exactly the expected size, with type narrowing.
+ */
+export function assertMapSize(value, expectedSize, message) {
+    const matcher = mapOfSize(expectedSize);
+    if (!matcher.matches(value)) {
+        throw new AssertionError(message ?? buildMapSizeMessage(value, expectedSize), value, matcher.represent());
+    }
+}
+function buildMapSizeMessage(value, expectedSize) {
+    if (!(value instanceof Map)) {
+        return `Expected ${desc(value)} to be a Map of size ${repr(expectedSize)}.`;
+    }
+    return `Expected ${desc(value)} to have size ${repr(expectedSize)}, but it had size ${repr(value.size)}.`;
+}
+//# sourceMappingURL=map-size.assert.js.map

package/dist/assert/map-size/map-size.assert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-size.assert.js","sourceRoot":"","sources":["../../../src/assert/map-size/map-size.assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAkBhD;;GAEG;AACH,MAAM,UAAU,aAAa,CAC3B,KAAc,EACd,YAAoB,EACpB,OAAgB;IAEhB,MAAM,OAAO,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC;IAExC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,cAAc,CACtB,OAAO,IAAI,mBAAmB,CAAC,KAAK,EAAE,YAAY,CAAC,EACnD,KAAK,EACL,OAAO,CAAC,SAAS,EAAE,CACpB,CAAC;IACJ,CAAC;AACH,CAAC;AAED,SAAS,mBAAmB,CAAC,KAAc,EAAE,YAAoB;IAC/D,IAAI,CAAC,CAAC,KAAK,YAAY,GAAG,CAAC,EAAE,CAAC;QAC5B,OAAO,YAAY,IAAI,CAAC,KAAK,CAAC,wBAAwB,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC;IAC9E,CAAC;IAED,OAAO,YAAY,IAAI,CAAC,KAAK,CAAC,iBAAiB,IAAI,CAAC,YAAY,CAAC,qBAAqB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC;AAC5G,CAAC"}

package/dist/assert/map-size/map-size.match.d.ts

@@ -0,0 +1,6 @@
+import { type MapOfSizeMatcher } from "./map-size.type.js";
+/**
+ * Matcher for a Map with exactly the expected size.
+ */
+export declare function mapOfSize<const N extends number>(expectedSize: N): MapOfSizeMatcher<N>;
+//# sourceMappingURL=map-size.match.d.ts.map

package/dist/assert/map-size/map-size.match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-size.match.d.ts","sourceRoot":"","sources":["../../../src/assert/map-size/map-size.match.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,EAC9C,YAAY,EAAE,CAAC,GACd,gBAAgB,CAAC,CAAC,CAAC,CAYrB"}

package/dist/assert/map-size/map-size.match.js

@@ -0,0 +1,15 @@
+import { createMatcher } from "../../match/match.js";
+import { repr } from "../../describe/describe.js";
+import { mapOfSizeMatcher, } from "./map-size.type.js";
+/**
+ * Matcher for a Map with exactly the expected size.
+ */
+export function mapOfSize(expectedSize) {
+    return {
+        ...createMatcher((value) => value instanceof Map && value.size === expectedSize, () => `Map of size ${repr(expectedSize)}`, () => `Map(${repr(expectedSize)})`),
+        // Runtime marker used only to make the matcher type nominal for type-level
+        // refinement dispatch. It is not part of the user-facing matcher behaviour.
+        [mapOfSizeMatcher]: expectedSize,
+    };
+}
+//# sourceMappingURL=map-size.match.js.map

package/dist/assert/map-size/map-size.match.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-size.match.js","sourceRoot":"","sources":["../../../src/assert/map-size/map-size.match.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AAClD,OAAO,EACL,gBAAgB,GAGjB,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,MAAM,UAAU,SAAS,CACvB,YAAe;IAEf,OAAO;QACL,GAAG,aAAa,CACd,CAAC,KAAK,EAA2C,EAAE,CACjD,KAAK,YAAY,GAAG,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,EACrD,GAAG,EAAE,CAAC,eAAe,IAAI,CAAC,YAAY,CAAC,EAAE,EACzC,GAAG,EAAE,CAAC,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CACnC;QACD,2EAA2E;QAC3E,4EAA4E;QAC5E,CAAC,gBAAgB,CAAC,EAAE,YAAY;KACjC,CAAC;AACJ,CAAC"}