import { t as __commonJSMin } from "./shared-3g9mwCWP.mjs";

//#region ../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/branding.js
var require_branding = /* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
}));

//#endregion
//#region ../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/messages.js
var require_messages = /* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	/**
	* @internal
	*/
	const inverted = Symbol("inverted");
	/**
	* @internal
	*/
	const expectNull = Symbol("expectNull");
	/**
	* @internal
	*/
	const expectUndefined = Symbol("expectUndefined");
	/**
	* @internal
	*/
	const expectNumber = Symbol("expectNumber");
	/**
	* @internal
	*/
	const expectString = Symbol("expectString");
	/**
	* @internal
	*/
	const expectBoolean = Symbol("expectBoolean");
	/**
	* @internal
	*/
	const expectVoid = Symbol("expectVoid");
	/**
	* @internal
	*/
	const expectFunction = Symbol("expectFunction");
	/**
	* @internal
	*/
	const expectObject = Symbol("expectObject");
	/**
	* @internal
	*/
	const expectArray = Symbol("expectArray");
	/**
	* @internal
	*/
	const expectSymbol = Symbol("expectSymbol");
	/**
	* @internal
	*/
	const expectAny = Symbol("expectAny");
	/**
	* @internal
	*/
	const expectUnknown = Symbol("expectUnknown");
	/**
	* @internal
	*/
	const expectNever = Symbol("expectNever");
	/**
	* @internal
	*/
	const expectNullable = Symbol("expectNullable");
	/**
	* @internal
	*/
	const expectBigInt = Symbol("expectBigInt");
}));

//#endregion
//#region ../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/overloads.js
var require_overloads = /* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
}));

//#endregion
//#region ../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/utils.js
var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	/**
	* @internal
	*/
	const secret = Symbol("secret");
	/**
	* @internal
	*/
	const mismatch = Symbol("mismatch");
	/**
	* A type which should match anything passed as a value but *doesn't*
	* match {@linkcode Mismatch}. It helps TypeScript select the right overload
	* for {@linkcode PositiveExpectTypeOf.toEqualTypeOf | .toEqualTypeOf()} and
	* {@linkcode PositiveExpectTypeOf.toMatchTypeOf | .toMatchTypeOf()}.
	*
	* @internal
	*/
	const avalue = Symbol("avalue");
}));

//#endregion
//#region ../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/index.js
var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
		if (k2 === undefined) k2 = k;
		var desc = Object.getOwnPropertyDescriptor(m, k);
		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
			desc = {
				enumerable: true,
				get: function() {
					return m[k];
				}
			};
		}
		Object.defineProperty(o, k2, desc);
	}) : (function(o, m, k, k2) {
		if (k2 === undefined) k2 = k;
		o[k2] = m[k];
	}));
	var __exportStar = exports && exports.__exportStar || function(m, exports$1) {
		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.expectTypeOf = void 0;
	__exportStar(require_branding(), exports);
	__exportStar(require_messages(), exports);
	__exportStar(require_overloads(), exports);
	__exportStar(require_utils(), exports);
	const fn = () => true;
	/**
	* Similar to Jest's `expect`, but with type-awareness.
	* Gives you access to a number of type-matchers that let you make assertions about the
	* form of a reference or generic type parameter.
	*
	* @example
	* ```ts
	* import { foo, bar } from '../foo'
	* import { expectTypeOf } from 'expect-type'
	*
	* test('foo types', () => {
	*   // make sure `foo` has type { a: number }
	*   expectTypeOf(foo).toMatchTypeOf({ a: 1 })
	*   expectTypeOf(foo).toHaveProperty('a').toBeNumber()
	*
	*   // make sure `bar` is a function taking a string:
	*   expectTypeOf(bar).parameter(0).toBeString()
	*   expectTypeOf(bar).returns.not.toBeAny()
	* })
	* ```
	*
	* @description
	* See the [full docs](https://npmjs.com/package/expect-type#documentation) for lots more examples.
	*/
	const expectTypeOf = (_actual) => {
		const nonFunctionProperties = [
			"parameters",
			"returns",
			"resolves",
			"not",
			"items",
			"constructorParameters",
			"thisParameter",
			"instance",
			"guards",
			"asserts",
			"branded"
		];
		const obj = {
			toBeAny: fn,
			toBeUnknown: fn,
			toBeNever: fn,
			toBeFunction: fn,
			toBeObject: fn,
			toBeArray: fn,
			toBeString: fn,
			toBeNumber: fn,
			toBeBoolean: fn,
			toBeVoid: fn,
			toBeSymbol: fn,
			toBeNull: fn,
			toBeUndefined: fn,
			toBeNullable: fn,
			toBeBigInt: fn,
			toMatchTypeOf: fn,
			toEqualTypeOf: fn,
			toBeConstructibleWith: fn,
			toMatchObjectType: fn,
			toExtend: fn,
			map: exports.expectTypeOf,
			toBeCallableWith: exports.expectTypeOf,
			extract: exports.expectTypeOf,
			exclude: exports.expectTypeOf,
			pick: exports.expectTypeOf,
			omit: exports.expectTypeOf,
			toHaveProperty: exports.expectTypeOf,
			parameter: exports.expectTypeOf
		};
		const getterProperties = nonFunctionProperties;
		getterProperties.forEach((prop) => Object.defineProperty(obj, prop, { get: () => (0, exports.expectTypeOf)({}) }));
		return obj;
	};
	exports.expectTypeOf = expectTypeOf;
}));

//#endregion
const __cjs_export__ = require_dist();
export const { expectTypeOf } = __cjs_export__;
export default __cjs_export__;