@udibo/oauth2 0.14.1 → 0.15.0

package/dist/utils/_constant-time.js

@@ -0,0 +1,19 @@
+/**
+ * Internal constant-time byte comparison for modules that also run in
+ * browsers, where `node:crypto` is unavailable.
+ *
+ * @module
+ */
+/**
+ * Compares two byte arrays without an early exit on the first differing byte.
+ * Returns `false` immediately when the lengths differ, so the length is not
+ * secret.
+ */
+export function constantTimeEqual(a, b) {
+    if (a.byteLength !== b.byteLength)
+        return false;
+    let difference = 0;
+    for (let i = 0; i < a.byteLength; i++)
+        difference |= a[i] ^ b[i];
+    return difference === 0;
+}

package/{esm → dist}/utils/_default-fetch.js

@@ -84,7 +84,10 @@ async function fetchOnOwnConnection(createHttpClient, input, init) {
 }
 function watchBody(response, onError) {
     const { body: source, status } = response;
-    if (!source || status < 200 || status > 599 || NULL_BODY_STATUSES.has(status)) {
+    if (!source ||
+        status < 200 ||
+        status > 599 ||
+        NULL_BODY_STATUSES.has(status)) {
         return response;
     }
     const reader = source.getReader();

package/dist/utils/_delay.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Internal cancellable sleep shared by the client and the identity service.
+ *
+ * @module
+ */
+/**
+ * Resolves after `ms` milliseconds. When `signal` aborts first, rejects with
+ * the signal's reason and clears the timer. Uses the global `setTimeout`, so
+ * fake timers control it.
+ */
+export declare function delay(ms: number, options?: {
+    signal?: AbortSignal;
+}): Promise<void>;

package/dist/utils/_delay.js

@@ -0,0 +1,28 @@
+/**
+ * Internal cancellable sleep shared by the client and the identity service.
+ *
+ * @module
+ */
+/**
+ * Resolves after `ms` milliseconds. When `signal` aborts first, rejects with
+ * the signal's reason and clears the timer. Uses the global `setTimeout`, so
+ * fake timers control it.
+ */
+export function delay(ms, options = {}) {
+    const { signal } = options;
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal?.reason);
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/utils/_encoding.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Internal binary-to-text codecs shared by the modules that run in both
+ * browsers and servers.
+ *
+ * @module
+ */
+/** Lowercase hexadecimal encoding of `bytes`. */
+export declare function encodeHex(bytes: Uint8Array | ArrayBuffer): string;
+/** Standard-alphabet base64 with `=` padding. */
+export declare function encodeBase64(bytes: Uint8Array): string;
+/**
+ * Decodes standard-alphabet base64, padded or not.
+ *
+ * @throws {TypeError} on a character outside the alphabet.
+ * @throws {RangeError} on a length that leaves a remainder of 1 when divided
+ * by 4.
+ */
+export declare function decodeBase64(input: string): Uint8Array;
+/** URL-safe base64 without padding. */
+export declare function encodeBase64Url(bytes: Uint8Array): string;
+/**
+ * Decodes URL-safe base64, padded or not.
+ *
+ * @throws {TypeError} on a character outside the alphabet.
+ * @throws {RangeError} on a length that leaves a remainder of 1 when divided
+ * by 4.
+ */
+export declare function decodeBase64Url(input: string): Uint8Array;
+/** RFC 4648 base32 with `=` padding. */
+export declare function encodeBase32(bytes: Uint8Array): string;
+/**
+ * Decodes RFC 4648 base32. The input length must be a multiple of 8,
+ * counting padding.
+ *
+ * @throws {TypeError} on a character outside the alphabet or an unpadded
+ * length.
+ * @throws {RangeError} on a length no encoding can produce.
+ */
+export declare function decodeBase32(input: string): Uint8Array;

package/dist/utils/_encoding.js

@@ -0,0 +1,126 @@
+/**
+ * Internal binary-to-text codecs shared by the modules that run in both
+ * browsers and servers.
+ *
+ * @module
+ */
+const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const BASE64URL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+const BASE32 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+const lookup = (alphabet) => new Map([...alphabet].map((char, index) => [char, index]));
+const BASE64_LOOKUP = lookup(BASE64);
+const BASE64URL_LOOKUP = lookup(BASE64URL);
+const BASE32_LOOKUP = lookup(BASE32);
+const HEX = Array.from({ length: 256 }, (_, byte) => byte.toString(16).padStart(2, "0"));
+/** Lowercase hexadecimal encoding of `bytes`. */
+export function encodeHex(bytes) {
+    const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+    let out = "";
+    for (const byte of view)
+        out += HEX[byte];
+    return out;
+}
+function encodeBits(bytes, alphabet, bitsPerChar) {
+    let out = "";
+    let buffer = 0;
+    let bits = 0;
+    const mask = (1 << bitsPerChar) - 1;
+    for (const byte of bytes) {
+        buffer = (buffer << 8) | byte;
+        bits += 8;
+        while (bits >= bitsPerChar) {
+            bits -= bitsPerChar;
+            out += alphabet[(buffer >> bits) & mask];
+        }
+        buffer &= (1 << bits) - 1;
+    }
+    if (bits > 0)
+        out += alphabet[(buffer << (bitsPerChar - bits)) & mask];
+    return out;
+}
+function pad(encoded, multiple) {
+    return (encoded + "=".repeat((multiple - (encoded.length % multiple)) % multiple));
+}
+function decodeBits(input, table, bitsPerChar, name, paddingWindow, invalidRemainders) {
+    let text = input;
+    for (let x = Math.max(0, text.length - paddingWindow); x < text.length; ++x) {
+        if (text[x] === "=") {
+            for (let y = x + 1; y < text.length; ++y) {
+                if (text[y] !== "=") {
+                    throw new TypeError(`Cannot decode input as ${name}: Invalid character (${text[y]})`);
+                }
+            }
+            text = text.slice(0, x);
+            break;
+        }
+    }
+    const modulus = name === "base32" ? 8 : 4;
+    if (invalidRemainders.includes(text.length % modulus)) {
+        throw new RangeError(`Cannot decode input as ${name}: Length (${text.length}), excluding ` +
+            `padding, must not have a remainder of ${invalidRemainders.join(", ")} when divided by ${modulus}`);
+    }
+    const out = new Uint8Array(Math.floor((text.length * bitsPerChar) / 8));
+    let buffer = 0;
+    let bits = 0;
+    let index = 0;
+    for (const char of text) {
+        const value = table.get(char);
+        if (value === undefined) {
+            throw new TypeError(`Cannot decode input as ${name}: Invalid character (${char})`);
+        }
+        buffer = (buffer << bitsPerChar) | value;
+        bits += bitsPerChar;
+        if (bits >= 8) {
+            bits -= 8;
+            out[index++] = (buffer >> bits) & 0xff;
+            buffer &= (1 << bits) - 1;
+        }
+    }
+    return out;
+}
+/** Standard-alphabet base64 with `=` padding. */
+export function encodeBase64(bytes) {
+    return pad(encodeBits(bytes, BASE64, 6), 4);
+}
+/**
+ * Decodes standard-alphabet base64, padded or not.
+ *
+ * @throws {TypeError} on a character outside the alphabet.
+ * @throws {RangeError} on a length that leaves a remainder of 1 when divided
+ * by 4.
+ */
+export function decodeBase64(input) {
+    return decodeBits(input, BASE64_LOOKUP, 6, "base64", 2, [1]);
+}
+/** URL-safe base64 without padding. */
+export function encodeBase64Url(bytes) {
+    return encodeBits(bytes, BASE64URL, 6);
+}
+/**
+ * Decodes URL-safe base64, padded or not.
+ *
+ * @throws {TypeError} on a character outside the alphabet.
+ * @throws {RangeError} on a length that leaves a remainder of 1 when divided
+ * by 4.
+ */
+export function decodeBase64Url(input) {
+    return decodeBits(input, BASE64URL_LOOKUP, 6, "base64", 2, [1]);
+}
+/** RFC 4648 base32 with `=` padding. */
+export function encodeBase32(bytes) {
+    return pad(encodeBits(bytes, BASE32, 5), 8);
+}
+/**
+ * Decodes RFC 4648 base32. The input length must be a multiple of 8,
+ * counting padding.
+ *
+ * @throws {TypeError} on a character outside the alphabet or an unpadded
+ * length.
+ * @throws {RangeError} on a length no encoding can produce.
+ */
+export function decodeBase32(input) {
+    if (input.length % 8 !== 0) {
+        throw new TypeError(`Invalid base32 string: length (${input.length}) must be a multiple of 8`);
+    }
+    return decodeBits(input, BASE32_LOOKUP, 5, "base32", 6, [1, 3, 6]);
+}

package/{esm → dist}/utils/authentication-context.d.ts

@@ -1,3 +1,3 @@
-import type { AuthenticationContext } from "../models/authentication.js";
+import type { AuthenticationContext } from "../models/authentication.ts";
 /** Copies verified event claims without sharing mutable method arrays. */
 export declare function snapshotAuthenticationContext(context: AuthenticationContext | undefined): AuthenticationContext | undefined;

package/{esm → dist}/utils/crypto.d.ts

@@ -22,9 +22,8 @@
  *
  * @module
  */
-import "../_dnt.polyfills.js";
-import { sha256Hash } from "../server/utils/hash.js";
-import { toArrayBuffer } from "./_buffer.js";
+import { sha256Hash } from "../server/utils/hash.ts";
+import { toArrayBuffer } from "./_buffer.ts";
 export { sha256Hash };
 export { toArrayBuffer };
 /** Constant-time string equality (length difference short-circuits to false). */

package/{esm → dist}/utils/crypto.js

@@ -22,11 +22,10 @@
  *
  * @module
  */
-import "../_dnt.polyfills.js";
-import { timingSafeEqual } from "../deps/jsr.io/@std/crypto/1.1.0/timing_safe_equal.js";
-import { decodeBase64Url, encodeBase64Url } from "../deps/jsr.io/@std/encoding/1.0.11/base64url.js";
 import { sha256Hash } from "../server/utils/hash.js";
 import { toArrayBuffer } from "./_buffer.js";
+import { constantTimeEqual } from "./_constant-time.js";
+import { decodeBase64Url, encodeBase64Url } from "./_encoding.js";
 export { sha256Hash };
 export { toArrayBuffer };
 function toBytes(secret) {
@@ -39,7 +38,7 @@ export function timingSafeEqualString(a, b) {
     const bBytes = encoder.encode(b);
     if (aBytes.byteLength !== bBytes.byteLength)
         return false;
-    return timingSafeEqual(aBytes, bBytes);
+    return constantTimeEqual(aBytes, bBytes);
 }
 /** URL-safe base64 encode (no padding). */
 export function base64urlEncode(bytes) {

package/{esm → dist}/utils/pkce.js

@@ -6,7 +6,7 @@
  * @see https://datatracker.ietf.org/doc/html/rfc7636
  * @module
  */
-import { encodeBase64Url } from "../deps/jsr.io/@std/encoding/1.0.11/base64url.js";
+import { encodeBase64Url } from "./_encoding.js";
 /**
  * Minimum length for code verifier per RFC 7636 Section 4.1.
  * @see https://datatracker.ietf.org/doc/html/rfc7636#section-4.1

package/{esm → dist}/utils/text.js

@@ -15,7 +15,7 @@ export const PROVIDER_TEXT_MAX_LENGTH = 200;
  * every byte a remote server chose that reaches a message.
  */
 export function sanitizeProviderText(value) {
-    // deno-lint-ignore no-control-regex
+    // oxlint-disable-next-line no-control-regex
     const flattened = value.replace(/[\u0000-\u001F\u007F-\u009F]+/g, " ");
     return flattened.trim().slice(0, PROVIDER_TEXT_MAX_LENGTH).toWellFormed();
 }

package/{esm → dist}/utils/url.d.ts

@@ -3,7 +3,6 @@
  *
  * @module
  */
-import "../_dnt.polyfills.js";
 /**
  * Open-redirect guard for a `return_to` / redirect target.
  *

package/{esm → dist}/utils/url.js

@@ -3,7 +3,6 @@
  *
  * @module
  */
-import "../_dnt.polyfills.js";
 const RESOLUTION_ORIGIN = "http://safe-return-to.invalid";
 function hasControlCharacter(value) {
     for (let index = 0; index < value.length; index++) {

package/package.json

@@ -1,92 +1,215 @@
 {
   "name": "@udibo/oauth2",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "description": "A flexible OAuth2 toolkit: framework-agnostic authorization & resource servers, a typed client, Hono adapters (including a backend-for-frontend), and React bindings.",
+  "keywords": [
+    "authorization-server",
+    "bff",
+    "hono",
+    "oauth2",
+    "oidc",
+    "openid-connect",
+    "react",
+    "resource-server"
+  ],
+  "homepage": "https://github.com/udibo/oauth2#readme",
+  "bugs": {
+    "url": "https://github.com/udibo/oauth2/issues"
+  },
+  "license": "MIT",
+  "author": "Udibo",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/udibo/oauth2.git"
   },
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/udibo/oauth2/issues"
+  "bin": {
+    "udibo-oauth2": "./dist/cli/bin.js"
   },
-  "module": "./esm/server/mod.js",
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "README.md",
+    "LICENSE",
+    "SECURITY.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
   "exports": {
     "./server": {
-      "import": "./esm/server/mod.js"
+      "types": "./dist/server/mod.d.ts",
+      "default": "./dist/server/mod.js"
     },
     "./server/authorization": {
-      "import": "./esm/server/authorization-server.js"
+      "types": "./dist/server/authorization-server.d.ts",
+      "default": "./dist/server/authorization-server.js"
     },
     "./server/resource": {
-      "import": "./esm/server/resource-server.js"
+      "types": "./dist/server/resource-server.d.ts",
+      "default": "./dist/server/resource-server.js"
     },
     "./server/public-suffix": {
-      "import": "./esm/server/public-suffix/mod.js"
+      "types": "./dist/server/public-suffix/mod.d.ts",
+      "default": "./dist/server/public-suffix/mod.js"
     },
     "./client": {
-      "import": "./esm/client/mod.js"
+      "types": "./dist/client/mod.d.ts",
+      "default": "./dist/client/mod.js"
     },
     "./identity": {
-      "import": "./esm/identity/mod.js"
+      "types": "./dist/identity/mod.d.ts",
+      "default": "./dist/identity/mod.js"
     },
     "./identity/external": {
-      "import": "./esm/identity/external/mod.js"
+      "types": "./dist/identity/external/mod.d.ts",
+      "default": "./dist/identity/external/mod.js"
     },
     "./identity/mfa": {
-      "import": "./esm/identity/mfa/mod.js"
+      "types": "./dist/identity/mfa/mod.d.ts",
+      "default": "./dist/identity/mfa/mod.js"
     },
     "./identity/migration": {
-      "import": "./esm/identity/migration.js"
+      "types": "./dist/identity/migration.d.ts",
+      "default": "./dist/identity/migration.js"
     },
     "./hono/resource-server": {
-      "import": "./esm/adapters/hono/resource-server.js"
+      "types": "./dist/adapters/hono/resource-server.d.ts",
+      "default": "./dist/adapters/hono/resource-server.js"
     },
     "./hono/authorization-server": {
-      "import": "./esm/adapters/hono/authorization-server.js"
+      "types": "./dist/adapters/hono/authorization-server.d.ts",
+      "default": "./dist/adapters/hono/authorization-server.js"
     },
     "./hono/bff": {
-      "import": "./esm/adapters/hono/bff/mod.js"
+      "types": "./dist/adapters/hono/bff/mod.d.ts",
+      "default": "./dist/adapters/hono/bff/mod.js"
     },
     "./hono/bff/testing": {
-      "import": "./esm/adapters/hono/bff/testing.js"
+      "types": "./dist/adapters/hono/bff/testing.d.ts",
+      "default": "./dist/adapters/hono/bff/testing.js"
     },
     "./hono/identity": {
-      "import": "./esm/adapters/hono/identity.js"
+      "types": "./dist/adapters/hono/identity.d.ts",
+      "default": "./dist/adapters/hono/identity.js"
     },
     "./hono/log": {
-      "import": "./esm/adapters/hono/log.js"
+      "types": "./dist/adapters/hono/log.d.ts",
+      "default": "./dist/adapters/hono/log.js"
     },
     "./react": {
-      "import": "./esm/react/mod.js"
+      "types": "./dist/react/mod.d.ts",
+      "default": "./dist/react/mod.js"
     },
     "./react/components": {
-      "import": "./esm/react/components/mod.js"
+      "types": "./dist/react/components/mod.d.ts",
+      "default": "./dist/react/components/mod.js"
     },
     "./react/testing": {
-      "import": "./esm/react/testing.js"
+      "types": "./dist/react/testing.d.ts",
+      "default": "./dist/react/testing.js"
     },
     "./testing": {
-      "import": "./esm/testing/mod.js"
+      "types": "./dist/testing/mod.d.ts",
+      "default": "./dist/testing/mod.js"
     },
     "./testing/contract": {
-      "import": "./esm/testing/contract/mod.js"
+      "types": "./dist/testing/contract/mod.d.ts",
+      "default": "./dist/testing/contract/mod.js"
     },
     "./crypto": {
-      "import": "./esm/utils/crypto.js"
+      "types": "./dist/utils/crypto.d.ts",
+      "default": "./dist/utils/crypto.js"
     },
     "./url": {
-      "import": "./esm/utils/url.js"
-    }
+      "types": "./dist/utils/url.d.ts",
+      "default": "./dist/utils/url.js"
+    },
+    "./package.json": "./package.json"
   },
-  "scripts": {},
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.build.json",
+    "check": "pnpm build && pnpm typecheck:examples && pnpm lint && pnpm fmt:check && tsc --noEmit && pnpm doc:lint && pnpm doc:check && pnpm doc:links && pnpm llms:check",
+    "typecheck:examples": "pnpm -r --filter \"./examples/**\" --filter \"./templates/**\" typecheck",
+    "fmt": "oxfmt",
+    "fmt:check": "oxfmt --check",
+    "lint": "oxlint --type-aware --type-check",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:browser": "playwright test",
+    "smoke": "node scripts/npm-smoke.ts",
+    "jsr:dry-run": "jsr publish --dry-run --allow-dirty",
+    "doc:lint": "node scripts/doc-lint.ts",
+    "doc:check": "node scripts/doc-check.ts",
+    "doc:links": "node scripts/doc-links.ts",
+    "llms:generate": "node scripts/llms.ts",
+    "llms:check": "node scripts/llms.ts --check",
+    "psl:update": "node scripts/public-suffix-list.ts",
+    "psl:check": "node scripts/public-suffix-list.ts --check",
+    "release:verify": "node scripts/verify-release.ts"
   },
   "dependencies": {
-    "@types/react": "^19.2.17",
+    "@hono/node-server": "^2.1.3",
+    "@udibo/http-error": "^0.12.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.63.0",
+    "@sebbo2002/semantic-release-jsr": "3.2.1",
+    "@semantic-release/changelog": "6.0.3",
+    "@semantic-release/exec": "7.1.0",
+    "@semantic-release/git": "10.0.1",
+    "@semantic-release/github": "12.0.8",
+    "@semantic-release/npm": "13.1.5",
+    "@testing-library/dom": "^10.4.2",
+    "@testing-library/react": "^16.3.3",
+    "@types/node": "^26.6.4",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vitest/coverage-v8": "^5.0.3",
+    "axe-core": "^4.14.0",
+    "conventional-changelog-conventionalcommits": "9.3.1",
+    "hono": "^4.13.13",
+    "jsdom": "^30.1.2",
+    "jsr": "^0.14.3",
+    "oxfmt": "^0.72.0",
+    "oxlint": "^1.87.0",
+    "oxlint-tsgolint": "^7.0.2003",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "semantic-release": "25.0.5",
+    "typescript": "^7.0.2",
+    "vite": "^8.3.3",
+    "vitest": "^5.0.3",
+    "yaml": "2.9.1"
+  },
+  "peerDependencies": {
+    "@types/react": "^19.0.0",
     "hono": "^4.7.0",
-    "react": "^19.0.0"
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "vitest": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "hono": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
+    "@types/react": {
+      "optional": true
+    },
+    "vitest": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22"
   },
-  "_generatedBy": "dnt@0.43.2"
+  "packageManager": "pnpm@12.10.1"
 }

package/esm/_dnt.polyfills.d.ts

@@ -1,31 +0,0 @@
-declare global {
-    interface Object {
-        /**
-         * Determines whether an object has a property with the specified name.
-         * @param o An object.
-         * @param v A property name.
-         */
-        hasOwn(o: object, v: PropertyKey): boolean;
-    }
-}
-export {};
-declare global {
-    interface Error {
-        cause?: unknown;
-    }
-}
-export {};
-declare global {
-    interface PromiseConstructor {
-        /**
-         * Creates a Promise that can be resolved or rejected using provided functions.
-         * @returns An object containing `promise` promise object, `resolve` and `reject` functions.
-         */
-        withResolvers<T>(): {
-            promise: Promise<T>;
-            resolve: (value: T | PromiseLike<T>) => void;
-            reject: (reason?: any) => void;
-        };
-    }
-}
-export {};

package/esm/_dnt.polyfills.js

@@ -1,26 +0,0 @@
-// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
-if (!Object.hasOwn) {
-    Object.defineProperty(Object, "hasOwn", {
-        value: function (object, property) {
-            if (object == null) {
-                throw new TypeError("Cannot convert undefined or null to object");
-            }
-            return Object.prototype.hasOwnProperty.call(Object(object), property);
-        },
-        configurable: true,
-        enumerable: false,
-        writable: true,
-    });
-}
-// https://github.com/tc39/proposal-promise-with-resolvers/blob/3a78801e073e99217dbeb2c43ba7212f3bdc8b83/polyfills.js#L1C1-L9C2
-if (Promise.withResolvers === undefined) {
-    Promise.withResolvers = () => {
-        const out = {};
-        out.promise = new Promise((resolve_, reject_) => {
-            out.resolve = resolve_;
-            out.reject = reject_;
-        });
-        return out;
-    };
-}
-export {};

package/esm/deps/jsr.io/@std/assert/1.0.19/almost_equals.d.ts

@@ -1,29 +0,0 @@
-/**
- * Make an assertion that `actual` and `expected` are almost equal numbers
- * through a given tolerance. It can be used to take into account IEEE-754
- * double-precision floating-point representation limitations. If the values
- * are not almost equal then throw.
- *
- * The default tolerance is one hundred thousandth of a percent of the
- * expected value.
- *
- * @example Usage
- * ```ts ignore
- * import { assertAlmostEquals } from "@std/assert";
- *
- * assertAlmostEquals(0.01, 0.02); // Throws
- * assertAlmostEquals(1e-8, 1e-9); // Throws
- * assertAlmostEquals(1.000000001e-8, 1.000000002e-8); // Doesn't throw
- * assertAlmostEquals(0.01, 0.02, 0.1); // Doesn't throw
- * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16); // Doesn't throw
- * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17); // Throws
- * ```
- *
- * @param actual The actual value to compare.
- * @param expected The expected value to compare.
- * @param tolerance The tolerance to consider the values almost equal. The
- * default is one hundred thousandth of a percent of the expected value.
- * @param msg The optional message to include in the error.
- * @throws {AssertionError} If the values are not almost equal.
- */
-export declare function assertAlmostEquals(actual: number, expected: number, tolerance?: number, msg?: string): void;