yummies 7.13.0 → 7.14.0

package/assert.cjs

@@ -0,0 +1,146 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chunk = require("./chunk-CVq3Gv4J.cjs");
+let yummies_common = require("yummies/common");
+//#region src/assert/_exports.ts
+/**
+* ---header-docs-section---
+* # yummies/assert
+*
+* ## Description
+*
+* Runtime **assertions** for invariants, narrowing, and exhaustiveness. Helpers throw
+* {@link AssertionError} with an optional message (`string` or {@link MaybeFn}) so failing fast stays
+* explicit without a heavy assertion library. Use `assert.ok`, `assert.defined`, `assert.fail`, and
+* the rest on the namespace export from the package entry.
+*
+* ## Usage
+*
+* ```ts
+* import { assert } from "yummies/assert";
+*
+* assert.ok(user.id, "user id is required");
+* assert.defined(maybeName);
+* ```
+*/
+var _exports_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	AssertionError: () => AssertionError,
+	defined: () => defined,
+	fail: () => fail,
+	instanceOf: () => instanceOf,
+	invariant: () => invariant,
+	never: () => unreachable,
+	notNull: () => notNull,
+	notUndefined: () => notUndefined,
+	ok: () => ok,
+	unreachable: () => unreachable
+});
+/**
+* Error thrown by assertion helpers in this module.
+*/
+var AssertionError = class extends Error {
+	name = "AssertionError";
+};
+function resolveAssertMessage(message, fallback) {
+	if (message === void 0) return fallback;
+	return (0, yummies_common.callFunction)(message);
+}
+/**
+* Throws when `condition` is falsy; narrows the type when it is truthy.
+*
+* @param condition Value treated as a boolean guard.
+* @param message Optional message or lazy message factory.
+*
+* @example
+* ```ts
+* assert.ok(user.id, "user id is required");
+* ```
+*/
+function ok(condition, message) {
+	if (!condition) throw new AssertionError(resolveAssertMessage(message, "Assertion failed"));
+}
+/**
+* Same as {@link ok}; common alias for internal invariants (e.g. after optional checks).
+*/
+var invariant = ok;
+/**
+* Throws when the value is `null` or `undefined`; otherwise narrows away nullish.
+*
+* @param value Possibly nullish value.
+* @param message Optional message or lazy message factory.
+*
+* @example
+* ```ts
+* assert.defined(maybeName, "name must be present");
+* ```
+*/
+function defined(value, message) {
+	if (value == null) throw new AssertionError(resolveAssertMessage(message, "Expected a defined value"));
+}
+/**
+* Throws when the value is `null`; allows `undefined` unless combined with other checks.
+*
+* @param value Value that may be `null`.
+* @param message Optional message or lazy message factory.
+*/
+function notNull(value, message) {
+	if (value === null) throw new AssertionError(resolveAssertMessage(message, "Expected a non-null value"));
+}
+/**
+* Throws when the value is `undefined`.
+*
+* @param value Value that may be `undefined`.
+* @param message Optional message or lazy message factory.
+*/
+function notUndefined(value, message) {
+	if (value === void 0) throw new AssertionError(resolveAssertMessage(message, "Expected a defined value"));
+}
+/**
+* Always throws; use for branches that must be impossible or as a typed “abort”.
+*
+* @param message Optional message or lazy message factory.
+*
+* @example
+* ```ts
+* function parse(kind: "a" | "b") {
+*   if (kind === "a") return 1;
+*   if (kind === "b") return 2;
+*   assert.fail("unreachable");
+* }
+* ```
+*/
+function fail(message) {
+	throw new AssertionError(resolveAssertMessage(message, "Unreachable"));
+}
+/**
+* Exhaustiveness helper: call with a `never` value when all union cases are handled.
+*
+* @param value Should be `never` when the type checker is satisfied.
+* @param message Optional message (this path always throws, so a lazy factory is unnecessary).
+*/
+function unreachable(value, message) {
+	throw new AssertionError(resolveAssertMessage(message, `Unexpected value: ${String(value)}`));
+}
+/**
+* Throws when `value` is not an instance of `ctor`.
+*
+* @param value Value to check.
+* @param ctor Constructor used with `instanceof`.
+* @param message Optional message or lazy message factory.
+*
+* @example
+* ```ts
+* assert.instanceOf(el, HTMLElement, "expected a DOM element");
+* ```
+*/
+function instanceOf(value, ctor, message) {
+	if (!(value instanceof ctor)) throw new AssertionError(resolveAssertMessage(message, `Expected instance of ${ctor.name}`));
+}
+//#endregion
+Object.defineProperty(exports, "assert", {
+	enumerable: true,
+	get: function() {
+		return _exports_exports;
+	}
+});
+
+//# sourceMappingURL=assert.cjs.map

package/assert.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.cjs","names":[],"sources":["../src/assert/_exports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/assert\n *\n * ## Description\n *\n * Runtime **assertions** for invariants, narrowing, and exhaustiveness. Helpers throw\n * {@link AssertionError} with an optional message (`string` or {@link MaybeFn}) so failing fast stays\n * explicit without a heavy assertion library. Use `assert.ok`, `assert.defined`, `assert.fail`, and\n * the rest on the namespace export from the package entry.\n *\n * ## Usage\n *\n * ```ts\n * import { assert } from \"yummies/assert\";\n *\n * assert.ok(user.id, \"user id is required\");\n * assert.defined(maybeName);\n * ```\n */\n\nimport { callFunction } from 'yummies/common';\nimport type { Maybe, MaybeFn } from 'yummies/types';\n\n/**\n * Error thrown by assertion helpers in this module.\n */\nexport class AssertionError extends Error {\n  override name = 'AssertionError';\n}\n\nfunction resolveAssertMessage(\n  message: MaybeFn<string> | undefined,\n  fallback: string,\n): string {\n  if (message === undefined) {\n    return fallback;\n  }\n  return callFunction(message);\n}\n\n/**\n * Throws when `condition` is falsy; narrows the type when it is truthy.\n *\n * @param condition Value treated as a boolean guard.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.ok(user.id, \"user id is required\");\n * ```\n */\nexport function ok(\n  condition: unknown,\n  message?: MaybeFn<string>,\n): asserts condition {\n  if (!condition) {\n    throw new AssertionError(resolveAssertMessage(message, 'Assertion failed'));\n  }\n}\n\n/**\n * Same as {@link ok}; common alias for internal invariants (e.g. after optional checks).\n */\nexport const invariant: typeof ok = ok;\n\n/**\n * Throws when the value is `null` or `undefined`; otherwise narrows away nullish.\n *\n * @param value Possibly nullish value.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.defined(maybeName, \"name must be present\");\n * ```\n */\nexport function defined<T>(\n  value: Maybe<T>,\n  message?: MaybeFn<string>,\n): asserts value is NonNullable<T> {\n  if (value == null) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `null`; allows `undefined` unless combined with other checks.\n *\n * @param value Value that may be `null`.\n * @param message Optional message or lazy message factory.\n */\nexport function notNull<T>(\n  value: T | null,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (value === null) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a non-null value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `undefined`.\n *\n * @param value Value that may be `undefined`.\n * @param message Optional message or lazy message factory.\n */\nexport function notUndefined<T>(\n  value: T | undefined,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (value === undefined) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Always throws; use for branches that must be impossible or as a typed “abort”.\n *\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * function parse(kind: \"a\" | \"b\") {\n *   if (kind === \"a\") return 1;\n *   if (kind === \"b\") return 2;\n *   assert.fail(\"unreachable\");\n * }\n * ```\n */\nexport function fail(message?: MaybeFn<string>): never {\n  throw new AssertionError(resolveAssertMessage(message, 'Unreachable'));\n}\n\n/**\n * Exhaustiveness helper: call with a `never` value when all union cases are handled.\n *\n * @param value Should be `never` when the type checker is satisfied.\n * @param message Optional message (this path always throws, so a lazy factory is unnecessary).\n */\nexport function unreachable(value: never, message?: string): never {\n  throw new AssertionError(\n    resolveAssertMessage(message, `Unexpected value: ${String(value)}`),\n  );\n}\n\n/**\n * Alias for {@link unreachable} (common name in switch exhaustiveness snippets).\n */\nexport { unreachable as never };\n\n/**\n * Throws when `value` is not an instance of `ctor`.\n *\n * @param value Value to check.\n * @param ctor Constructor used with `instanceof`.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.instanceOf(el, HTMLElement, \"expected a DOM element\");\n * ```\n */\nexport function instanceOf<T>(\n  value: unknown,\n  ctor: abstract new (...args: never[]) => T,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!(value instanceof ctor)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, `Expected instance of ${ctor.name}`),\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,IAAa,iBAAb,cAAoC,MAAM;CACxC,OAAgB;;AAGlB,SAAS,qBACP,SACA,UACQ;AACR,KAAI,YAAY,KAAA,EACd,QAAO;AAET,SAAA,GAAA,eAAA,cAAoB,QAAQ;;;;;;;;;;;;;AAc9B,SAAgB,GACd,WACA,SACmB;AACnB,KAAI,CAAC,UACH,OAAM,IAAI,eAAe,qBAAqB,SAAS,mBAAmB,CAAC;;;;;AAO/E,IAAa,YAAuB;;;;;;;;;;;;AAapC,SAAgB,QACd,OACA,SACiC;AACjC,KAAI,SAAS,KACX,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,QACd,OACA,SACoB;AACpB,KAAI,UAAU,KACZ,OAAM,IAAI,eACR,qBAAqB,SAAS,4BAA4B,CAC3D;;;;;;;;AAUL,SAAgB,aACd,OACA,SACoB;AACpB,KAAI,UAAU,KAAA,EACZ,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;;;;;;;;;AAkBL,SAAgB,KAAK,SAAkC;AACrD,OAAM,IAAI,eAAe,qBAAqB,SAAS,cAAc,CAAC;;;;;;;;AASxE,SAAgB,YAAY,OAAc,SAAyB;AACjE,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,OAAO,MAAM,GAAG,CACpE;;;;;;;;;;;;;;AAoBH,SAAgB,WACd,OACA,MACA,SACoB;AACpB,KAAI,EAAE,iBAAiB,MACrB,OAAM,IAAI,eACR,qBAAqB,SAAS,wBAAwB,KAAK,OAAO,CACnE"}

package/assert.d.ts

@@ -0,0 +1,134 @@
+import { Maybe, MaybeFn } from 'yummies/types';
+
+/**
+ * ---header-docs-section---
+ * # yummies/assert
+ *
+ * ## Description
+ *
+ * Runtime **assertions** for invariants, narrowing, and exhaustiveness. Helpers throw
+ * {@link AssertionError} with an optional message (`string` or {@link MaybeFn}) so failing fast stays
+ * explicit without a heavy assertion library. Use `assert.ok`, `assert.defined`, `assert.fail`, and
+ * the rest on the namespace export from the package entry.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { assert } from "yummies/assert";
+ *
+ * assert.ok(user.id, "user id is required");
+ * assert.defined(maybeName);
+ * ```
+ */
+
+/**
+ * Error thrown by assertion helpers in this module.
+ */
+declare class AssertionError extends Error {
+    name: string;
+}
+/**
+ * Throws when `condition` is falsy; narrows the type when it is truthy.
+ *
+ * @param condition Value treated as a boolean guard.
+ * @param message Optional message or lazy message factory.
+ *
+ * @example
+ * ```ts
+ * assert.ok(user.id, "user id is required");
+ * ```
+ */
+declare function ok(condition: unknown, message?: MaybeFn<string>): asserts condition;
+/**
+ * Same as {@link ok}; common alias for internal invariants (e.g. after optional checks).
+ */
+declare const invariant: typeof ok;
+/**
+ * Throws when the value is `null` or `undefined`; otherwise narrows away nullish.
+ *
+ * @param value Possibly nullish value.
+ * @param message Optional message or lazy message factory.
+ *
+ * @example
+ * ```ts
+ * assert.defined(maybeName, "name must be present");
+ * ```
+ */
+declare function defined<T>(value: Maybe<T>, message?: MaybeFn<string>): asserts value is NonNullable<T>;
+/**
+ * Throws when the value is `null`; allows `undefined` unless combined with other checks.
+ *
+ * @param value Value that may be `null`.
+ * @param message Optional message or lazy message factory.
+ */
+declare function notNull<T>(value: T | null, message?: MaybeFn<string>): asserts value is T;
+/**
+ * Throws when the value is `undefined`.
+ *
+ * @param value Value that may be `undefined`.
+ * @param message Optional message or lazy message factory.
+ */
+declare function notUndefined<T>(value: T | undefined, message?: MaybeFn<string>): asserts value is T;
+/**
+ * Always throws; use for branches that must be impossible or as a typed “abort”.
+ *
+ * @param message Optional message or lazy message factory.
+ *
+ * @example
+ * ```ts
+ * function parse(kind: "a" | "b") {
+ *   if (kind === "a") return 1;
+ *   if (kind === "b") return 2;
+ *   assert.fail("unreachable");
+ * }
+ * ```
+ */
+declare function fail(message?: MaybeFn<string>): never;
+/**
+ * Exhaustiveness helper: call with a `never` value when all union cases are handled.
+ *
+ * @param value Should be `never` when the type checker is satisfied.
+ * @param message Optional message (this path always throws, so a lazy factory is unnecessary).
+ */
+declare function unreachable(value: never, message?: string): never;
+
+/**
+ * Throws when `value` is not an instance of `ctor`.
+ *
+ * @param value Value to check.
+ * @param ctor Constructor used with `instanceof`.
+ * @param message Optional message or lazy message factory.
+ *
+ * @example
+ * ```ts
+ * assert.instanceOf(el, HTMLElement, "expected a DOM element");
+ * ```
+ */
+declare function instanceOf<T>(value: unknown, ctor: abstract new (...args: never[]) => T, message?: MaybeFn<string>): asserts value is T;
+
+type _exports_AssertionError = AssertionError;
+declare const _exports_AssertionError: typeof AssertionError;
+declare const _exports_defined: typeof defined;
+declare const _exports_fail: typeof fail;
+declare const _exports_instanceOf: typeof instanceOf;
+declare const _exports_invariant: typeof invariant;
+declare const _exports_notNull: typeof notNull;
+declare const _exports_notUndefined: typeof notUndefined;
+declare const _exports_ok: typeof ok;
+declare const _exports_unreachable: typeof unreachable;
+declare namespace _exports {
+  export {
+    _exports_AssertionError as AssertionError,
+    _exports_defined as defined,
+    _exports_fail as fail,
+    _exports_instanceOf as instanceOf,
+    _exports_invariant as invariant,
+    unreachable as never,
+    _exports_notNull as notNull,
+    _exports_notUndefined as notUndefined,
+    _exports_ok as ok,
+    _exports_unreachable as unreachable,
+  };
+}
+
+export { _exports as assert };

package/assert.js

@@ -0,0 +1,140 @@
+import { n as __exportAll } from "./chunk-YKewjYmz.js";
+import { callFunction } from "yummies/common";
+//#region src/assert/_exports.ts
+/**
+* ---header-docs-section---
+* # yummies/assert
+*
+* ## Description
+*
+* Runtime **assertions** for invariants, narrowing, and exhaustiveness. Helpers throw
+* {@link AssertionError} with an optional message (`string` or {@link MaybeFn}) so failing fast stays
+* explicit without a heavy assertion library. Use `assert.ok`, `assert.defined`, `assert.fail`, and
+* the rest on the namespace export from the package entry.
+*
+* ## Usage
+*
+* ```ts
+* import { assert } from "yummies/assert";
+*
+* assert.ok(user.id, "user id is required");
+* assert.defined(maybeName);
+* ```
+*/
+var _exports_exports = /* @__PURE__ */ __exportAll({
+	AssertionError: () => AssertionError,
+	defined: () => defined,
+	fail: () => fail,
+	instanceOf: () => instanceOf,
+	invariant: () => invariant,
+	never: () => unreachable,
+	notNull: () => notNull,
+	notUndefined: () => notUndefined,
+	ok: () => ok,
+	unreachable: () => unreachable
+});
+/**
+* Error thrown by assertion helpers in this module.
+*/
+var AssertionError = class extends Error {
+	name = "AssertionError";
+};
+function resolveAssertMessage(message, fallback) {
+	if (message === void 0) return fallback;
+	return callFunction(message);
+}
+/**
+* Throws when `condition` is falsy; narrows the type when it is truthy.
+*
+* @param condition Value treated as a boolean guard.
+* @param message Optional message or lazy message factory.
+*
+* @example
+* ```ts
+* assert.ok(user.id, "user id is required");
+* ```
+*/
+function ok(condition, message) {
+	if (!condition) throw new AssertionError(resolveAssertMessage(message, "Assertion failed"));
+}
+/**
+* Same as {@link ok}; common alias for internal invariants (e.g. after optional checks).
+*/
+var invariant = ok;
+/**
+* Throws when the value is `null` or `undefined`; otherwise narrows away nullish.
+*
+* @param value Possibly nullish value.
+* @param message Optional message or lazy message factory.
+*
+* @example
+* ```ts
+* assert.defined(maybeName, "name must be present");
+* ```
+*/
+function defined(value, message) {
+	if (value == null) throw new AssertionError(resolveAssertMessage(message, "Expected a defined value"));
+}
+/**
+* Throws when the value is `null`; allows `undefined` unless combined with other checks.
+*
+* @param value Value that may be `null`.
+* @param message Optional message or lazy message factory.
+*/
+function notNull(value, message) {
+	if (value === null) throw new AssertionError(resolveAssertMessage(message, "Expected a non-null value"));
+}
+/**
+* Throws when the value is `undefined`.
+*
+* @param value Value that may be `undefined`.
+* @param message Optional message or lazy message factory.
+*/
+function notUndefined(value, message) {
+	if (value === void 0) throw new AssertionError(resolveAssertMessage(message, "Expected a defined value"));
+}
+/**
+* Always throws; use for branches that must be impossible or as a typed “abort”.
+*
+* @param message Optional message or lazy message factory.
+*
+* @example
+* ```ts
+* function parse(kind: "a" | "b") {
+*   if (kind === "a") return 1;
+*   if (kind === "b") return 2;
+*   assert.fail("unreachable");
+* }
+* ```
+*/
+function fail(message) {
+	throw new AssertionError(resolveAssertMessage(message, "Unreachable"));
+}
+/**
+* Exhaustiveness helper: call with a `never` value when all union cases are handled.
+*
+* @param value Should be `never` when the type checker is satisfied.
+* @param message Optional message (this path always throws, so a lazy factory is unnecessary).
+*/
+function unreachable(value, message) {
+	throw new AssertionError(resolveAssertMessage(message, `Unexpected value: ${String(value)}`));
+}
+/**
+* Throws when `value` is not an instance of `ctor`.
+*
+* @param value Value to check.
+* @param ctor Constructor used with `instanceof`.
+* @param message Optional message or lazy message factory.
+*
+* @example
+* ```ts
+* assert.instanceOf(el, HTMLElement, "expected a DOM element");
+* ```
+*/
+function instanceOf(value, ctor, message) {
+	if (!(value instanceof ctor)) throw new AssertionError(resolveAssertMessage(message, `Expected instance of ${ctor.name}`));
+}
+//#endregion
+export { _exports_exports as assert };
+
+//# sourceMappingURL=assert.js.map

package/assert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.js","names":[],"sources":["../src/assert/_exports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/assert\n *\n * ## Description\n *\n * Runtime **assertions** for invariants, narrowing, and exhaustiveness. Helpers throw\n * {@link AssertionError} with an optional message (`string` or {@link MaybeFn}) so failing fast stays\n * explicit without a heavy assertion library. Use `assert.ok`, `assert.defined`, `assert.fail`, and\n * the rest on the namespace export from the package entry.\n *\n * ## Usage\n *\n * ```ts\n * import { assert } from \"yummies/assert\";\n *\n * assert.ok(user.id, \"user id is required\");\n * assert.defined(maybeName);\n * ```\n */\n\nimport { callFunction } from 'yummies/common';\nimport type { Maybe, MaybeFn } from 'yummies/types';\n\n/**\n * Error thrown by assertion helpers in this module.\n */\nexport class AssertionError extends Error {\n  override name = 'AssertionError';\n}\n\nfunction resolveAssertMessage(\n  message: MaybeFn<string> | undefined,\n  fallback: string,\n): string {\n  if (message === undefined) {\n    return fallback;\n  }\n  return callFunction(message);\n}\n\n/**\n * Throws when `condition` is falsy; narrows the type when it is truthy.\n *\n * @param condition Value treated as a boolean guard.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.ok(user.id, \"user id is required\");\n * ```\n */\nexport function ok(\n  condition: unknown,\n  message?: MaybeFn<string>,\n): asserts condition {\n  if (!condition) {\n    throw new AssertionError(resolveAssertMessage(message, 'Assertion failed'));\n  }\n}\n\n/**\n * Same as {@link ok}; common alias for internal invariants (e.g. after optional checks).\n */\nexport const invariant: typeof ok = ok;\n\n/**\n * Throws when the value is `null` or `undefined`; otherwise narrows away nullish.\n *\n * @param value Possibly nullish value.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.defined(maybeName, \"name must be present\");\n * ```\n */\nexport function defined<T>(\n  value: Maybe<T>,\n  message?: MaybeFn<string>,\n): asserts value is NonNullable<T> {\n  if (value == null) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `null`; allows `undefined` unless combined with other checks.\n *\n * @param value Value that may be `null`.\n * @param message Optional message or lazy message factory.\n */\nexport function notNull<T>(\n  value: T | null,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (value === null) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a non-null value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `undefined`.\n *\n * @param value Value that may be `undefined`.\n * @param message Optional message or lazy message factory.\n */\nexport function notUndefined<T>(\n  value: T | undefined,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (value === undefined) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Always throws; use for branches that must be impossible or as a typed “abort”.\n *\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * function parse(kind: \"a\" | \"b\") {\n *   if (kind === \"a\") return 1;\n *   if (kind === \"b\") return 2;\n *   assert.fail(\"unreachable\");\n * }\n * ```\n */\nexport function fail(message?: MaybeFn<string>): never {\n  throw new AssertionError(resolveAssertMessage(message, 'Unreachable'));\n}\n\n/**\n * Exhaustiveness helper: call with a `never` value when all union cases are handled.\n *\n * @param value Should be `never` when the type checker is satisfied.\n * @param message Optional message (this path always throws, so a lazy factory is unnecessary).\n */\nexport function unreachable(value: never, message?: string): never {\n  throw new AssertionError(\n    resolveAssertMessage(message, `Unexpected value: ${String(value)}`),\n  );\n}\n\n/**\n * Alias for {@link unreachable} (common name in switch exhaustiveness snippets).\n */\nexport { unreachable as never };\n\n/**\n * Throws when `value` is not an instance of `ctor`.\n *\n * @param value Value to check.\n * @param ctor Constructor used with `instanceof`.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.instanceOf(el, HTMLElement, \"expected a DOM element\");\n * ```\n */\nexport function instanceOf<T>(\n  value: unknown,\n  ctor: abstract new (...args: never[]) => T,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!(value instanceof ctor)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, `Expected instance of ${ctor.name}`),\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,IAAa,iBAAb,cAAoC,MAAM;CACxC,OAAgB;;AAGlB,SAAS,qBACP,SACA,UACQ;AACR,KAAI,YAAY,KAAA,EACd,QAAO;AAET,QAAO,aAAa,QAAQ;;;;;;;;;;;;;AAc9B,SAAgB,GACd,WACA,SACmB;AACnB,KAAI,CAAC,UACH,OAAM,IAAI,eAAe,qBAAqB,SAAS,mBAAmB,CAAC;;;;;AAO/E,IAAa,YAAuB;;;;;;;;;;;;AAapC,SAAgB,QACd,OACA,SACiC;AACjC,KAAI,SAAS,KACX,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,QACd,OACA,SACoB;AACpB,KAAI,UAAU,KACZ,OAAM,IAAI,eACR,qBAAqB,SAAS,4BAA4B,CAC3D;;;;;;;;AAUL,SAAgB,aACd,OACA,SACoB;AACpB,KAAI,UAAU,KAAA,EACZ,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;;;;;;;;;AAkBL,SAAgB,KAAK,SAAkC;AACrD,OAAM,IAAI,eAAe,qBAAqB,SAAS,cAAc,CAAC;;;;;;;;AASxE,SAAgB,YAAY,OAAc,SAAyB;AACjE,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,OAAO,MAAM,GAAG,CACpE;;;;;;;;;;;;;;AAoBH,SAAgB,WACd,OACA,MACA,SACoB;AACpB,KAAI,EAAE,iBAAiB,MACrB,OAAM,IAAI,eACR,qBAAqB,SAAS,wBAAwB,KAAK,OAAO,CACnE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yummies",
-  "version": "7.13.0",
+  "version": "7.14.0",
   "keywords": [
     "javascript",
     "typescript",
@@ -40,6 +40,12 @@
   },
   "type": "module",
   "exports": {
+    "./assert": {
+      "types": "./assert.d.ts",
+      "import": "./assert.js",
+      "require": "./assert.cjs",
+      "default": "./assert.js"
+    },
     "./async": {
       "types": "./async.d.ts",
       "import": "./async.js",