@muze-nl/assert 0.5.0 → 0.6.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Auke van Slooten
+Copyright (c) 2023 - 2026 Muze.nl
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -4,158 +4,78 @@
 [![npm bundle size](https://img.shields.io/bundlephobia/min/@muze-nl/assert)](https://www.npmjs.com/package/@muze-nl/assert)
 [![Project stage: Development][project-stage-badge: Development]][project-stage-page]
 
-# Assert: javascript optional assertion checking
-
-This is a light-weight library to do optional assertion checking. By default any assertions made are not tested. Assertion code is not run. Unless you toggle assertion checking, usually in developer mode, by calling `enable`. Now your assertions are run, and if any assertions fail, an error is thrown with information about the specific failure.
-
-This style of assertion testing is often used with [Design by Contract](https://en.wikipedia.org/wiki/Design_by_contract) software development. When implementing a fixed specification, like a W3C recommendation or RFC, using design by contract allows you to write code very similar to the specification.
-
-Here is an example from the [@muze-nl/metro-oidc](https://github.com/muze-nl/,etro-oidc) library, which shows how you can use Assert to check specification requirements, in a dense but readable way:
+# Assert: optional assertion checking
 
 ```javascript
-  // https://openid.net/specs/openid-connect-registration-1_0.html#ClientMetadata
-  const openid_client_metadata = {
-    redirect_uris: Required([validURL]),
-    response_types: Optional([]),
-    grant_types: Optional(anyOf('authorization_code','refresh_token')), //TODO: match response_types with grant_types
-    application_type: Optional(oneOf('native','web')),
-    contacts: Optional([validEmail]),
-    client_name: Optional(String),
-    logo_uri: Optional(validURL),
-    client_uri: Optional(validURL),
-    policy_uri: Optional(validURL),
-    tos_uri: Optional(validURL),
-    jwks_uri: Optional(validURL, not(MustHave('jwks'))),
-    jwks: Optional(validURL, not(MustHave('jwks_uri'))),
-    sector_identifier_uri: Optional(validURL),
-    subject_type: Optional(String),
-    id_token_signed_response_alg: Optional(oneOf(...validJWA)),
-    id_token_encrypted_response_alg: Optional(oneOf(...validJWA)),
-    id_token_encrypted_response_enc: Optional(oneOf(...validJWA), MustHave('id_token_encrypted_response_alg')),
-    userinfo_signed_response_alg: Optional(oneOf(...validJWA)),
-    userinfo_encrypted_response_alg: Optional(oneOf(...validJWA)),
-    userinfo_encrypted_response_enc: Optional(oneOf(...validJWA), MustHave('userinfo_encrypted_response_alg')),
-    request_object_signing_alg: Optional(oneOf(...validJWA)),
-    request_object_encryption_alg: Optional(oneOf(...validJWA)),
-    request_object_encryption_enc: Optional(oneOf(...validJWA)),
-    token_endpoint_auth_method: Optional(oneOf(...validAuthMethods)),
-    token_endpoint_auth_signing_alg: Optional(oneOf(...validJWA)),
-    default_max_age: Optional(Number),
-    require_auth_time: Optional(Boolean),
-    default_acr_values: Optional([String]),
-    initiate_login_uri: Optional([validURL]),
-    request_uris: Optional([validURL])
-  }
-
-  assert(options, {
-    client: Optional(instanceOf(metro.client().constructor)),
-    registration_endpoint: validURL, 
-    client_info: openid_client_metadata
-  })
-```
-
-_Note:_ This library was created as part of the [@muze-nl/metro](https://github.com/muze-nl/metro/) package initially, but has escaped its confines. In the rest of the documentation, when referring to 'middleware', we mean middleware modules for the metro http client in the browser.
+import { assert, enable, Optional, Required, oneOf, validURL } from '@muze-nl/assert/core'
 
-## Installation
+enable()
 
-### Using NPM:
+function registerClient(metadata) {
+	assert(metadata, {
+		redirect_uris: Required([validURL]),
+		application_type: Optional(oneOf('web', 'native')),
+		client_name: Optional(String)
+	})
 
-```shell
-npm install @muze-nl/assert
+	// continue with metadata known to match the expected shape
+}
 ```
 
-The include it in your javascript code like this:
-```javascript
-import * as assert from '@muze-nl/assert'
-```
+## Table of Contents
 
-Or if you are a fan of shorter assertions:
+1. [Introduction](#introduction)
+2. [Usage](#usage)
+3. [Documentation](#documentation)
+4. [License](#license)
 
-```javascript
-import { assert, enable, disable, Optional, Required, Recommended, oneOf, anyOf, not, validURL, instanceOf } from '@muze-nl/assert'
-```
+## Introduction
 
-### Using a CDN like jsdelivr
-```html
-<script src="https://cdn.jsdelivr.net/npm/@muze-nl/assert@0.3.4/dist/browser.js" crossorigin="anonymous"></script>
-```
+Assert is a lightweight library for optional runtime checks. It is meant for code that benefits from explicit developer feedback during development, but should not spend time validating assumptions in production unless you ask it to.
+
+Assertions are disabled by default. `assert()` returns immediately until you call `enable()`. When enabled, failed assertions throw an error with path-aware details. If you always want to validate and handle failures yourself, use `fails()` or `issues()` directly.
 
-Using a CDN like this means that assert is loaded globally as window.assert.
+This style is useful for design-by-contract checks, protocol implementations, middleware preconditions, mock servers, and other places where executable requirements make code easier to understand.
 
 ## Usage
 
-```javascript
-import { assert, Optional, Required, not, validURL } from '@muze-nl/assert'
+Install with npm:
 
-function myFunction(param1, param2) {
-  assert(param1, Required(validURL))
-  assert(param2, Optional(not(/foo.*/)))
-  // do your own stuff here
-}
+```shell
+npm install @muze-nl/assert
 ```
 
-When calling myFunction above, none of the assertions are actually checked, unless you enable assertion checking first, like this:
+Use the side-effect-free entry point when you want tree-shaking:
 
 ```javascript
-import * as assert from '@muze-nl/assert'
-
-assert.enable()
+import { assert, enable, Required, validURL } from '@muze-nl/assert/core'
 ```
 
-## Asserting preconditions
-
-When writing middleware there is usually quite a lot of preconditions to check. When a developer wants to use your middleware, it is nice to have explicit feedback about what he or she is doing wrong. However this is only useful during development. Once in production you should assume that there are no developer mistakes anymore... or at least that the end user has no use for detailed error reports about your middleware.
-
-This is especially true about mock middleware. Mock middleware is middleware that blocks the actual transmission of a request, and returns a mock response instead. Your browser doesn't actually fetch the requests URL.
-
-The [oauth2 middleware](https://github.com/muze-nl/metro-oauth2) for example, has unit tests that use the oauth2 mock-server middleware to mimick a server. This way you can be sure that the oauth2 client implementation works, without having to setup a real oauth2 server anywhere.
-
-Since these mock middleware servers are especially meant for the initial development of new middleware, they should assert as much as they can. And send comprehensive error messages to the console. Here the [`assert.fails()`](./docs/fails.md) method comes in handy.
-
-`assert.fails()` returns `false` if there are no problems. If one or more assertions do fail, it will return an array with messages about each failed assertion. So one way of using it is like this:
+The package root exports the same API and also assigns it to `globalThis.assert` for compatibility:
 
 ```javascript
-let error
-
-if (error = assert.fails(url, {
-  searchParams: {
-    response_type: 'code',
-    client_id: 'mockClientId',
-    state: assert.Optional(/.+/)
-  }
-})) {
-  return metro.response({
-    url: req.url,
-    status: 400,
-    statusText: 'Bad Request',
-    body: '400 Bad Request'
-  })
-}
+import * as assert from '@muze-nl/assert'
 ```
 
-The first parameter to `assert.fails` contains the data you want to check. The second (or third, fourth, etc.) contain the assertions. If the data is an object, the assertions can use the same property names to add assertions for those specific properties. Here the `url.searchParams.response_type` must be equal to `code`, or the assertion will fail. You can also use numbers and booleans like this.
+In the browser, using a CDN:
 
-You can also add functions to the assertions. In this case the `assert.optional()` method adds a function that will only fail if the property is set and not `null`, but does not match the assertions passed to `assert.optional()`.
+```html
+<script src="https://cdn.jsdelivr.net/npm/@muze-nl/assert/dist/assert.min.js" crossorigin="anonymous"></script>
+```
 
-An assertion may also be a regular expression. If the property value fails to match that expression, the assertion fails. Here the `url.searchParams.state` is tested to make sure that, if it is set, it must not be empty.
+This loads the API as `window.assert`.
 
-In a mock middleware function, it is all well and good to always test your preconditions. But in production many preconditions may be assumed to be valid. These preconditions are not expected to fail in production, only in development. In that case you may use [`assert.check()`]('./docs/check.md'). This function by default does nothing. Only when you enable assertions does this function do anything. This allows you to selectively turn on assertions only in a development context. And avoid doing unnecessary work while in production. This is how it is used in the [oauth2 middleware](./middleware/oauth2.md) (not the mock server, the actual client code):
+## Documentation
 
-```javascript
-assert.assert(oauth2, {
-	client_id: /.+/,
-	authRedirectURL: /.+/,
-	scope: /.*/
-})
-```
-
-This makes sure that the `client_id` and `authRedirectURL` configuration options have been set and are not empty. But when the code is used in production, this should never happen. There is no need to constantly test for this. And in production it won't actually get checked. Only when you enable assertions will this code actually perform the tests:
+- [Documentation index](docs/)
+- [Tutorial](docs/tutorial.md)
+- [Reference](docs/reference/)
+- [Creating custom assertion checks](docs/reference/#creating-custom-assertion-checks)
+- [fails()](docs/reference/fails.md), [issues()](docs/reference/issues.md), and [formatIssues()](docs/reference/formatIssues.md)
 
-```javascript
-assert.enable()
-```
+## License
 
-Once the [`assert.enable()`](./docs/enable.md) function is called, now `assert.check()` will throw an error if any assertion fails. The error is also logged to the console.
+This software is licensed under the MIT open source license. See the [License](./LICENSE) file.
 
 [project-stage-badge: Development]: https://img.shields.io/badge/Project%20Stage-Development-yellowgreen.svg
 [project-stage-page]: https://blog.pother.ca/project-stages/

package/dist/assert.js

@@ -0,0 +1,473 @@
+(() => {
+  var __defProp = Object.defineProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/assert-core.mjs
+  var assert_core_exports = {};
+  __export(assert_core_exports, {
+    Optional: () => Optional,
+    Recommended: () => Recommended,
+    Required: () => Required,
+    allOf: () => allOf,
+    anyOf: () => anyOf,
+    assert: () => assert,
+    disable: () => disable,
+    enable: () => enable,
+    error: () => error,
+    fails: () => fails,
+    formatIssue: () => formatIssue,
+    formatIssues: () => formatIssues,
+    instanceOf: () => instanceOf,
+    issues: () => issues,
+    not: () => not,
+    oneOf: () => oneOf,
+    validEmail: () => validEmail,
+    validURL: () => validURL,
+    warn: () => warn
+  });
+  var assertEnabled = false;
+  function enable() {
+    assertEnabled = true;
+  }
+  function disable() {
+    assertEnabled = false;
+  }
+  function appendPath(path = "", key) {
+    if (typeof path == "undefined" || path == null) {
+      path = "";
+    }
+    if (typeof key == "number") {
+      return `${path}[${key}]`;
+    }
+    return `${path}.${key}`;
+  }
+  function pathToArray(path = "") {
+    if (Array.isArray(path)) {
+      return path;
+    }
+    if (!path) {
+      return [];
+    }
+    let result = [];
+    let matcher = /(?:^|\.)([^.\[\]]+)|\[(\d+)\]/g;
+    let match;
+    while (match = matcher.exec(path)) {
+      if (typeof match[1] != "undefined") {
+        result.push(match[1]);
+      } else if (typeof match[2] != "undefined") {
+        result.push(Number(match[2]));
+      }
+    }
+    return result;
+  }
+  function pathToString(path = []) {
+    if (typeof path == "string") {
+      return path.startsWith(".") ? path.slice(1) : path;
+    }
+    return path.map((part, index) => {
+      if (typeof part == "number") {
+        return `[${part}]`;
+      }
+      return `${index ? "." : ""}${part}`;
+    }).join("");
+  }
+  function describeFunction(value) {
+    if (value === String) {
+      return "string";
+    }
+    if (value === Number) {
+      return "number";
+    }
+    if (value === Boolean) {
+      return "boolean";
+    }
+    return value.name || "function";
+  }
+  function clip(text, maxLength = 60) {
+    if (text.length <= maxLength) {
+      return text;
+    }
+    return text.slice(0, maxLength - 1) + "\u2026";
+  }
+  function quoteString(value) {
+    return `'${clip(String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n"))}'`;
+  }
+  function jsonSummary(value) {
+    try {
+      let json = JSON.stringify(value);
+      if (typeof json == "string") {
+        return clip(json);
+      }
+    } catch (e) {
+    }
+    let name = value?.constructor?.name;
+    if (name && name != "Object") {
+      return name;
+    }
+    return Object.prototype.toString.call(value);
+  }
+  function formatValue(value) {
+    if (typeof value == "string") {
+      return quoteString(value);
+    }
+    if (typeof value == "undefined") {
+      return "undefined";
+    }
+    if (value === null) {
+      return "null";
+    }
+    if (typeof value == "function") {
+      return describeFunction(value);
+    }
+    if (value instanceof RegExp) {
+      return value.toString();
+    }
+    if (typeof value == "number" || typeof value == "boolean" || typeof value == "bigint") {
+      return String(value);
+    }
+    if (typeof value == "symbol") {
+      return value.toString();
+    }
+    return jsonSummary(value);
+  }
+  function describeExpected(value) {
+    if (value === String || value === Number || value === Boolean) {
+      return describeFunction(value);
+    }
+    if (typeof value == "function") {
+      return describeFunction(value);
+    }
+    if (value instanceof RegExp) {
+      return value.toString();
+    }
+    if (Array.isArray(value)) {
+      return "[" + value.map(describeExpected).join(", ") + "]";
+    }
+    return formatValue(value);
+  }
+  function describeOneOf(patterns) {
+    return patterns.map(describeExpected).join(", ");
+  }
+  function conciseMessage(message, actual, expected) {
+    if (message == "data and pattern are not equal") {
+      return `expected ${formatValue(expected)}, found ${formatValue(actual)}`;
+    }
+    if (message == "data does not match pattern" || /^data\[\d+\] does not match pattern$/.test(message)) {
+      return `expected ${describeExpected(expected)}, found ${formatValue(actual)}`;
+    }
+    if (message == "data is undefined, should match pattern") {
+      return `missing; expected ${describeExpected(expected)}`;
+    }
+    if (message == "data is required") {
+      return "required";
+    }
+    if (message == "data is an empty string, which is not allowed") {
+      return "empty string is not allowed";
+    }
+    if (message == "data is not an object, pattern is") {
+      return "data is not an object";
+    }
+    if (message == "data is not an instanceof pattern") {
+      return `expected instance of ${describeExpected(expected)}, found ${formatValue(actual)}`;
+    }
+    if (message == "data does not match oneOf patterns" || message == "data does not match anyOf patterns") {
+      return `expected one of ${describeOneOf(expected)}, found ${formatValue(actual)}`;
+    }
+    if (message == "data matches pattern, when required not to") {
+      return `must not match ${describeExpected(expected)}`;
+    }
+    return message;
+  }
+  function formatIssue(issue, options = {}) {
+    if (!issue || typeof issue != "object") {
+      return String(issue);
+    }
+    let path = issue.pathString || pathToString(issue.path || []) || "value";
+    let indent = options.indent ?? "";
+    return `${indent}${path}: ${issue.message}`;
+  }
+  function formatIssues(issues2, options = {}) {
+    if (!issues2) {
+      return false;
+    }
+    let indent = options.indent ?? "  - ";
+    return (Array.isArray(issues2) ? issues2 : [issues2]).map((issue) => formatIssue(issue, { ...options, indent }));
+  }
+  function issueFromProblem(problem) {
+    if (!problem || typeof problem != "object") {
+      return {
+        path: [],
+        pathString: "",
+        message: String(problem),
+        expected: void 0,
+        actual: void 0
+      };
+    }
+    let path = pathToArray(problem.path);
+    let pathString = pathToString(path);
+    let actual = problem.actual ?? problem.found;
+    let expected = describeExpected(problem.expected);
+    let message = conciseMessage(problem.message, actual, problem.expected);
+    return {
+      path,
+      pathString,
+      message,
+      expected,
+      actual
+    };
+  }
+  function problemsToIssues(problems) {
+    if (!problems) {
+      return [];
+    }
+    let result = [];
+    for (let problem of Array.isArray(problems) ? problems : [problems]) {
+      if (!problem) {
+        continue;
+      }
+      if (problem && typeof problem == "object" && problem.problems) {
+        let nested = problemsToIssues(problem.problems);
+        if (nested.length) {
+          result = result.concat(nested);
+          continue;
+        }
+      }
+      result.push(issueFromProblem(problem));
+    }
+    return result;
+  }
+  function assert(source, test) {
+    if (assertEnabled) {
+      let problems = fails(source, test);
+      if (problems) {
+        let assertionIssues = problemsToIssues(problems);
+        let formattedIssues = formatIssues(assertionIssues);
+        let message = "Assertions failed:\n" + formattedIssues.join("\n");
+        console.error("\u{1F170}\uFE0F  " + message);
+        throw new Error(message, {
+          cause: { problems, issues: assertionIssues, source }
+        });
+      }
+    }
+  }
+  function Optional(pattern) {
+    return function _Optional(data, root, path) {
+      if (typeof data != "undefined" && data != null && typeof pattern != "undefined") {
+        return fails(data, pattern, root, path);
+      }
+    };
+  }
+  function Required(pattern) {
+    return function _Required(data, root, path) {
+      if (data == null || typeof data == "undefined") {
+        return error("data is required", data, pattern || "any value", path);
+      } else if (typeof pattern != "undefined") {
+        return fails(data, pattern, root, path);
+      } else {
+        return false;
+      }
+    };
+  }
+  function Recommended(pattern) {
+    return function _Recommended(data, root, path) {
+      if (data == null || typeof data == "undefined") {
+        warn("data does not contain recommended value", data, pattern, path);
+        return false;
+      } else {
+        return fails(data, pattern, root, path);
+      }
+    };
+  }
+  function oneOf(...patterns) {
+    return function _oneOf(data, root, path) {
+      for (let pattern of patterns) {
+        if (!fails(data, pattern, root, path)) {
+          return false;
+        }
+      }
+      return error("data does not match oneOf patterns", data, patterns, path);
+    };
+  }
+  function anyOf(...patterns) {
+    return function _anyOf(data, root, path) {
+      if (!Array.isArray(data)) {
+        return error("data is not an array", data, "anyOf", path);
+      }
+      for (let [index, value] of data.entries()) {
+        let itemPath = appendPath(path, index);
+        if (oneOf(...patterns)(value, root, itemPath)) {
+          return error("data does not match anyOf patterns", value, patterns, itemPath);
+        }
+      }
+      return false;
+    };
+  }
+  function allOf(...patterns) {
+    return function _allOf(data, root, path) {
+      let problems = [];
+      for (let pattern of patterns) {
+        problems = problems.concat(fails(data, pattern, root, path));
+      }
+      problems = problems.filter(Boolean);
+      if (problems.length) {
+        return error("data does not match all given patterns", data, patterns, path, problems);
+      }
+    };
+  }
+  function validURL(data, root, path) {
+    try {
+      if (data instanceof URL) {
+        data = data.href;
+      }
+      let url = new URL(data);
+      if (url.href != data) {
+        if (!(url.href + "/" == data || url.href == data + "/")) {
+          return error("data is not a valid url", data, "validURL", path);
+        }
+      }
+    } catch (e) {
+      return error("data is not a valid url", data, "validURL", path);
+    }
+  }
+  function validEmail(data, root, path) {
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(data)) {
+      return error("data is not a valid email", data, "validEmail", path);
+    }
+  }
+  function instanceOf(constructor) {
+    return function _instanceOf(data, root, path) {
+      if (!(data instanceof constructor)) {
+        return error("data is not an instanceof pattern", data, constructor, path);
+      }
+    };
+  }
+  function not(pattern) {
+    return function _not(data, root, path) {
+      if (!fails(data, pattern, root, path)) {
+        return error("data matches pattern, when required not to", data, pattern, path);
+      }
+    };
+  }
+  function issues(data, pattern, root) {
+    let problems = fails(data, pattern, root);
+    if (!problems) {
+      return false;
+    }
+    return problemsToIssues(problems);
+  }
+  function fails(data, pattern, root, path = "") {
+    if (typeof root == "undefined") {
+      root = data;
+    }
+    let problems = [];
+    if (pattern === Boolean) {
+      if (typeof data != "boolean" && !(data instanceof Boolean)) {
+        problems.push(error("data is not a boolean", data, pattern, path));
+      }
+    } else if (pattern === Number) {
+      if (typeof data != "number" && !(data instanceof Number)) {
+        problems.push(error("data is not a number", data, pattern, path));
+      }
+    } else if (pattern === String) {
+      if (typeof data != "string" && !(data instanceof String)) {
+        problems.push(error("data is not a string", data, pattern, path));
+      }
+      if (data == "") {
+        problems.push(error("data is an empty string, which is not allowed", data, pattern, path));
+      }
+    } else if (pattern instanceof RegExp) {
+      if (Array.isArray(data)) {
+        let index = data.findIndex((element, index2) => fails(element, pattern, root, appendPath(path, index2)));
+        if (index > -1) {
+          problems.push(error("data[" + index + "] does not match pattern", data[index], pattern, appendPath(path, index)));
+        }
+      } else if (typeof data == "undefined") {
+        problems.push(error("data is undefined, should match pattern", data, pattern, path));
+      } else if (!pattern.test(data)) {
+        problems.push(error("data does not match pattern", data, pattern, path));
+      }
+    } else if (pattern instanceof Function) {
+      let problem = pattern(data, root, path);
+      if (problem) {
+        if (Array.isArray(problem)) {
+          problems = problems.concat(problem);
+        } else {
+          problems.push(problem);
+        }
+      }
+    } else if (Array.isArray(pattern)) {
+      if (!Array.isArray(data)) {
+        problems.push(error("data is not an array", data, [], path));
+      } else {
+        for (let p of pattern) {
+          for (let index of data.keys()) {
+            let problem = fails(data[index], p, root, appendPath(path, index));
+            if (Array.isArray(problem)) {
+              problems = problems.concat(problem);
+            } else if (problem) {
+              problems.push(problem);
+            }
+          }
+        }
+      }
+    } else if (pattern && typeof pattern == "object") {
+      if (Array.isArray(data)) {
+        let index = data.findIndex((element, index2) => fails(element, pattern, root, appendPath(path, index2)));
+        if (index > -1) {
+          problems.push(error("data[" + index + "] does not match pattern", data[index], pattern, appendPath(path, index)));
+        }
+      } else if (!data || typeof data != "object") {
+        problems.push(error("data is not an object, pattern is", data, pattern, path));
+      } else {
+        if (data instanceof URLSearchParams) {
+          data = Object.fromEntries(data);
+        }
+        if (pattern instanceof Function) {
+          let result = fails(data, pattern, root, path);
+          if (result) {
+            problems = problems.concat(result);
+          }
+        } else {
+          for (const [patternKey, subpattern] of Object.entries(pattern)) {
+            let result = fails(data[patternKey], subpattern, root, appendPath(path, patternKey));
+            if (result) {
+              problems = problems.concat(result);
+            }
+          }
+        }
+      }
+    } else {
+      if (pattern != data) {
+        problems.push(error("data and pattern are not equal", data, pattern, path));
+      }
+    }
+    if (problems.length) {
+      return problems;
+    }
+    return false;
+  }
+  function error(message, found, expected, path = "", problems) {
+    let pathParts = pathToArray(path);
+    let result = {
+      path,
+      pathString: pathToString(pathParts),
+      pathParts,
+      message,
+      found,
+      expected
+    };
+    if (problems) {
+      result.problems = problems;
+    }
+    return result;
+  }
+  function warn(message, data, pattern, path) {
+    console.warn("\u{1F170}\uFE0F  Assert: " + path, message, pattern, data);
+  }
+
+  // src/assert.mjs
+  globalThis.assert = { ...assert_core_exports };
+})();