@udibo/oauth2 0.14.1 → 0.15.0

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

@@ -1,47 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-/**
- * 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 function assertAlmostEquals(actual, expected, tolerance, msg) {
-    if (Object.is(actual, expected)) {
-        return;
-    }
-    const delta = Math.abs(expected - actual);
-    if (tolerance === undefined) {
-        tolerance = isFinite(expected) ? Math.abs(expected * 1e-7) : 1e-7;
-    }
-    if (delta <= tolerance) {
-        return;
-    }
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    const f = (n) => Number.isInteger(n) ? n : n.toExponential();
-    throw new AssertionError(`Expected actual: "${f(actual)}" to be close to "${f(expected)}": \
-delta "${f(delta)}" is greater than "${f(tolerance)}"${msgSuffix}`);
-}

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

@@ -1,28 +0,0 @@
-/** An array-like object (`Array`, `Uint8Array`, `NodeList`, etc.) that is not a string */
-export type ArrayLikeArg<T> = ArrayLike<T> & object;
-/**
- * Asserts that `actual` contains all values in `expected`, using deep equality
- * for non-primitive values.
- *
- * @example Usage with primitives
- * ```ts ignore
- * import { assertArrayIncludes } from "@std/assert";
- *
- * assertArrayIncludes([1, 2, 3], [2, 3]); // Passes
- * assertArrayIncludes([1, 2, 3], [4]); // Throws
- * ```
- *
- * @example Usage with objects (deep equality)
- * ```ts ignore
- * import { assertArrayIncludes } from "@std/assert";
- *
- * assertArrayIncludes([{ a: 1 }, { b: 2 }], [{ a: 1 }]); // Passes
- * ```
- *
- * @typeParam T The element type of the arrays.
- * @param actual The array-like object to search within.
- * @param expected The values that must be present in `actual`.
- * @param msg Optional message to display on failure.
- * @throws {AssertionError} If any value in `expected` is not found in `actual`.
- */
-export declare function assertArrayIncludes<T>(actual: ArrayLikeArg<T>, expected: ArrayLikeArg<T>, msg?: string): void;

package/esm/deps/jsr.io/@std/assert/1.0.19/array_includes.js

@@ -1,65 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-import { equal } from "./equal.js";
-import { format } from "../../internal/1.0.14/format.js";
-import { AssertionError } from "./assertion_error.js";
-function isPrimitive(value) {
-    return value === null ||
-        typeof value !== "object" && typeof value !== "function";
-}
-/**
- * Asserts that `actual` contains all values in `expected`, using deep equality
- * for non-primitive values.
- *
- * @example Usage with primitives
- * ```ts ignore
- * import { assertArrayIncludes } from "@std/assert";
- *
- * assertArrayIncludes([1, 2, 3], [2, 3]); // Passes
- * assertArrayIncludes([1, 2, 3], [4]); // Throws
- * ```
- *
- * @example Usage with objects (deep equality)
- * ```ts ignore
- * import { assertArrayIncludes } from "@std/assert";
- *
- * assertArrayIncludes([{ a: 1 }, { b: 2 }], [{ a: 1 }]); // Passes
- * ```
- *
- * @typeParam T The element type of the arrays.
- * @param actual The array-like object to search within.
- * @param expected The values that must be present in `actual`.
- * @param msg Optional message to display on failure.
- * @throws {AssertionError} If any value in `expected` is not found in `actual`.
- */
-export function assertArrayIncludes(actual, expected, msg) {
-    const missing = [];
-    const expectedLen = expected.length;
-    const actualLen = actual.length;
-    for (let i = 0; i < expectedLen; i++) {
-        const item = expected[i];
-        let found;
-        if (isPrimitive(item)) {
-            // Fast path
-            found = Array.prototype.includes.call(actual, item);
-        }
-        else {
-            found = false;
-            for (let j = 0; j < actualLen; j++) {
-                if (equal(item, actual[j])) {
-                    found = true;
-                    break;
-                }
-            }
-        }
-        if (!found) {
-            missing.push(item);
-        }
-    }
-    if (missing.length === 0) {
-        return;
-    }
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    msg = `Expected actual: "${format(actual)}" to include: "${format(expected)}"${msgSuffix}\nmissing: ${format(missing)}`;
-    throw new AssertionError(msg);
-}

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

@@ -1,16 +0,0 @@
-/**
- * Make an assertion, an error will be thrown if `expr` does not have a truthy value.
- *
- * @example Usage
- * ```ts ignore
- * import { assert } from "@std/assert";
- *
- * assert("hello".includes("ello")); // Doesn't throw
- * assert("hello".includes("world")); // Throws
- * ```
- *
- * @param expr The expression to test.
- * @param msg The optional message to display if the assertion fails.
- * @throws {AssertionError} If `expr` is falsy.
- */
-export declare function assert(expr: unknown, msg?: string): asserts expr;

package/esm/deps/jsr.io/@std/assert/1.0.19/assert.js

@@ -1,23 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-/**
- * Make an assertion, an error will be thrown if `expr` does not have a truthy value.
- *
- * @example Usage
- * ```ts ignore
- * import { assert } from "@std/assert";
- *
- * assert("hello".includes("ello")); // Doesn't throw
- * assert("hello".includes("world")); // Throws
- * ```
- *
- * @param expr The expression to test.
- * @param msg The optional message to display if the assertion fails.
- * @throws {AssertionError} If `expr` is falsy.
- */
-export function assert(expr, msg = "") {
-    if (!expr) {
-        throw new AssertionError(msg);
-    }
-}

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

@@ -1,25 +0,0 @@
-/**
- * Error thrown when an assertion fails.
- *
- * @example Usage
- * ```ts ignore
- * import { AssertionError } from "@std/assert";
- *
- * try {
- *   throw new AssertionError("foo", { cause: "bar" });
- * } catch (error) {
- *   if (error instanceof AssertionError) {
- *     error.message === "foo"; // true
- *     error.cause === "bar"; // true
- *   }
- * }
- * ```
- */
-export declare class AssertionError extends Error {
-    /** Constructs a new instance.
-     *
-     * @param message The error message.
-     * @param options Additional options. This argument is still unstable. It may change in the future release.
-     */
-    constructor(message: string, options?: ErrorOptions);
-}

package/esm/deps/jsr.io/@std/assert/1.0.19/assertion_error.js

@@ -1,30 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-/**
- * Error thrown when an assertion fails.
- *
- * @example Usage
- * ```ts ignore
- * import { AssertionError } from "@std/assert";
- *
- * try {
- *   throw new AssertionError("foo", { cause: "bar" });
- * } catch (error) {
- *   if (error instanceof AssertionError) {
- *     error.message === "foo"; // true
- *     error.cause === "bar"; // true
- *   }
- * }
- * ```
- */
-export class AssertionError extends Error {
-    /** Constructs a new instance.
-     *
-     * @param message The error message.
-     * @param options Additional options. This argument is still unstable. It may change in the future release.
-     */
-    constructor(message, options) {
-        super(message, options);
-        this.name = "AssertionError";
-    }
-}

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

@@ -1,24 +0,0 @@
-/**
- * Deep equality comparison used in assertions.
- *
- * This function is based on value equality, but for some cases (such as data
- * that can only be read asynchronously or function properties) value equality
- * is not possible to determine. In such cases, reference equality is used
- * instead, which may cause false negatives for objects such as `Blob`s or
- * `Request`s.
- *
- * @param a The actual value
- * @param b The expected value
- * @returns `true` if the values are deeply equal, `false` otherwise
- *
- * @throws {TypeError} If either value is a `WeakMap` or `WeakSet`.
- *
- * @example Usage
- * ```ts
- * import { equal } from "@std/assert/equal";
- *
- * equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
- * equal({ foo: "bar" }, { foo: "baz" }); // Returns `false`
- * ```
- */
-export declare function equal(a: unknown, b: unknown): boolean;

package/esm/deps/jsr.io/@std/assert/1.0.19/equal.js

@@ -1,193 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-function isKeyedCollection(x) {
-    return x instanceof Set || x instanceof Map;
-}
-function prototypesEqual(a, b) {
-    const pa = Object.getPrototypeOf(a);
-    const pb = Object.getPrototypeOf(b);
-    return pa === pb ||
-        pa === Object.prototype && pb === null ||
-        pa === null && pb === Object.prototype;
-}
-function isBasicObjectOrArray(obj) {
-    const proto = Object.getPrototypeOf(obj);
-    return proto === null || proto === Object.prototype ||
-        proto === Array.prototype;
-}
-// Slightly faster than Reflect.ownKeys in V8 as of 12.9.202.13-rusty (2024-10-28)
-function ownKeys(obj) {
-    return [
-        ...Object.getOwnPropertyNames(obj),
-        ...Object.getOwnPropertySymbols(obj),
-    ];
-}
-function getKeysDeep(obj) {
-    const keys = new Set();
-    while (obj !== Object.prototype && obj !== Array.prototype && obj != null) {
-        for (const key of ownKeys(obj)) {
-            keys.add(key);
-        }
-        obj = Object.getPrototypeOf(obj);
-    }
-    return keys;
-}
-// deno-lint-ignore no-explicit-any
-const Temporal = globalThis.Temporal ?? Object.create(null);
-/** A non-exhaustive list of prototypes that can be accurately fast-path compared with `String(instance)` */
-const stringComparablePrototypes = new Set([
-    Intl.Locale,
-    RegExp,
-    Temporal.Duration,
-    Temporal.Instant,
-    Temporal.PlainDate,
-    Temporal.PlainDateTime,
-    Temporal.PlainTime,
-    Temporal.PlainYearMonth,
-    Temporal.PlainMonthDay,
-    Temporal.ZonedDateTime,
-    URL,
-    URLSearchParams,
-].filter((x) => x != null).map((x) => x.prototype));
-function isPrimitive(x) {
-    return typeof x === "string" ||
-        typeof x === "number" ||
-        typeof x === "boolean" ||
-        typeof x === "bigint" ||
-        typeof x === "symbol" ||
-        x == null;
-}
-const TypedArray = Object.getPrototypeOf(Uint8Array);
-function compareTypedArrays(a, b) {
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < b.length; i++) {
-        if (!sameValueZero(a[i], b[i]))
-            return false;
-    }
-    return true;
-}
-/** Check both strict equality (`0 == -0`) and `Object.is` (`NaN == NaN`) */
-function sameValueZero(a, b) {
-    return a === b || Object.is(a, b);
-}
-/**
- * Deep equality comparison used in assertions.
- *
- * This function is based on value equality, but for some cases (such as data
- * that can only be read asynchronously or function properties) value equality
- * is not possible to determine. In such cases, reference equality is used
- * instead, which may cause false negatives for objects such as `Blob`s or
- * `Request`s.
- *
- * @param a The actual value
- * @param b The expected value
- * @returns `true` if the values are deeply equal, `false` otherwise
- *
- * @throws {TypeError} If either value is a `WeakMap` or `WeakSet`.
- *
- * @example Usage
- * ```ts
- * import { equal } from "@std/assert/equal";
- *
- * equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
- * equal({ foo: "bar" }, { foo: "baz" }); // Returns `false`
- * ```
- */
-export function equal(a, b) {
-    const seen = new Map();
-    return (function compare(a, b) {
-        if (sameValueZero(a, b))
-            return true;
-        if (isPrimitive(a) || isPrimitive(b))
-            return false;
-        if (a instanceof Date && b instanceof Date) {
-            return Object.is(a.getTime(), b.getTime());
-        }
-        if (a && typeof a === "object" && b && typeof b === "object") {
-            if (!prototypesEqual(a, b)) {
-                return false;
-            }
-            if (a instanceof TypedArray) {
-                return compareTypedArrays(a, b);
-            }
-            if (a instanceof ArrayBuffer ||
-                (globalThis.SharedArrayBuffer && a instanceof SharedArrayBuffer)) {
-                return compareTypedArrays(new Uint8Array(a), new Uint8Array(b));
-            }
-            if (a instanceof WeakMap) {
-                throw new TypeError("Cannot compare WeakMap instances");
-            }
-            if (a instanceof WeakSet) {
-                throw new TypeError("Cannot compare WeakSet instances");
-            }
-            if (a instanceof WeakRef) {
-                return compare(a.deref(), b.deref());
-            }
-            if (seen.get(a) === b) {
-                return true;
-            }
-            if (Object.keys(a).length !== Object.keys(b).length) {
-                return false;
-            }
-            seen.set(a, b);
-            if (isKeyedCollection(a) && isKeyedCollection(b)) {
-                if (a.size !== b.size) {
-                    return false;
-                }
-                const aKeys = [...a.keys()];
-                const primitiveKeysFastPath = aKeys.every(isPrimitive);
-                if (primitiveKeysFastPath) {
-                    if (a instanceof Set) {
-                        return a.symmetricDifference(b).size === 0;
-                    }
-                    for (const key of aKeys) {
-                        if (!b.has(key) ||
-                            !compare(a.get(key), b.get(key))) {
-                            return false;
-                        }
-                    }
-                    return true;
-                }
-                let unmatchedEntries = a.size;
-                for (const [aKey, aValue] of a.entries()) {
-                    for (const [bKey, bValue] of b.entries()) {
-                        /* Given that Map keys can be references, we need
-                         * to ensure that they are also deeply equal */
-                        if (!compare(aKey, bKey))
-                            continue;
-                        if ((aKey === aValue && bKey === bValue) ||
-                            (compare(aValue, bValue))) {
-                            unmatchedEntries--;
-                            break;
-                        }
-                    }
-                }
-                return unmatchedEntries === 0;
-            }
-            let keys;
-            if (isBasicObjectOrArray(a)) {
-                // fast path
-                keys = ownKeys({ ...a, ...b });
-            }
-            else if (stringComparablePrototypes.has(Object.getPrototypeOf(a))) {
-                // medium path
-                return String(a) === String(b);
-            }
-            else {
-                // slow path
-                keys = getKeysDeep(a).union(getKeysDeep(b));
-            }
-            for (const key of keys) {
-                if (!compare(a[key], b[key])) {
-                    return false;
-                }
-                if (((key in a) && (!(key in b))) || ((key in b) && (!(key in a)))) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        return false;
-    })(a, b);
-}

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

@@ -1,36 +0,0 @@
-/**
- * Make an assertion that `actual` and `expected` are equal, deeply. If not
- * deeply equal, then throw.
- *
- * Type parameter can be specified to ensure values under comparison have the
- * same type.
- *
- * Note: This function is based on value equality, but for some cases (such as
- * data that can only be read asynchronously or function properties) value
- * equality is not possible to determine. In such cases, reference equality is
- * used instead, which may cause false negatives for objects such as `Blob`s or
- * `Request`s.
- *
- * @example Usage
- * ```ts ignore
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals("world", "world"); // Doesn't throw
- * assertEquals("hello", "world"); // Throws
- * ```
- * @example Compare `Blob` objects
- * ```ts ignore
- * import { assertEquals } from "@std/assert";
- *
- * const bytes1 = await new Blob(["foo"]).bytes();
- * const bytes2 = await new Blob(["foo"]).bytes();
- *
- * assertEquals(bytes1, bytes2);
- * ```
- *
- * @typeParam T The type of the values to compare. This is usually inferred.
- * @param actual The actual value to compare.
- * @param expected The expected value to compare.
- * @param msg The optional message to display if the assertion fails.
- */
-export declare function assertEquals<T>(actual: T, expected: T, msg?: string): void;

package/esm/deps/jsr.io/@std/assert/1.0.19/equals.js

@@ -1,61 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-import { equal } from "./equal.js";
-import { buildMessage } from "../../internal/1.0.14/build_message.js";
-import { diff } from "../../internal/1.0.14/diff.js";
-import { diffStr } from "../../internal/1.0.14/diff_str.js";
-import { format } from "../../internal/1.0.14/format.js";
-import { AssertionError } from "./assertion_error.js";
-/**
- * Make an assertion that `actual` and `expected` are equal, deeply. If not
- * deeply equal, then throw.
- *
- * Type parameter can be specified to ensure values under comparison have the
- * same type.
- *
- * Note: This function is based on value equality, but for some cases (such as
- * data that can only be read asynchronously or function properties) value
- * equality is not possible to determine. In such cases, reference equality is
- * used instead, which may cause false negatives for objects such as `Blob`s or
- * `Request`s.
- *
- * @example Usage
- * ```ts ignore
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals("world", "world"); // Doesn't throw
- * assertEquals("hello", "world"); // Throws
- * ```
- * @example Compare `Blob` objects
- * ```ts ignore
- * import { assertEquals } from "@std/assert";
- *
- * const bytes1 = await new Blob(["foo"]).bytes();
- * const bytes2 = await new Blob(["foo"]).bytes();
- *
- * assertEquals(bytes1, bytes2);
- * ```
- *
- * @typeParam T The type of the values to compare. This is usually inferred.
- * @param actual The actual value to compare.
- * @param expected The expected value to compare.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertEquals(actual, expected, msg) {
-    if (equal(actual, expected)) {
-        return;
-    }
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    let message = `Values are not equal${msgSuffix}`;
-    const actualString = format(actual);
-    const expectedString = format(expected);
-    const stringDiff = (typeof actual === "string") &&
-        (typeof expected === "string");
-    const diffResult = stringDiff
-        ? diffStr(actual, expected)
-        : diff(actualString.split("\n"), expectedString.split("\n"));
-    const diffMsg = buildMessage(diffResult, { stringDiff }, arguments[3])
-        .join("\n");
-    message = `${message}\n${diffMsg}`;
-    throw new AssertionError(message);
-}

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

@@ -1,17 +0,0 @@
-/**
- * Make an assertion that actual is not null or undefined.
- * If not then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertExists } from "@std/assert";
- *
- * assertExists("something"); // Doesn't throw
- * assertExists(undefined); // Throws
- * ```
- *
- * @typeParam T The type of the actual value.
- * @param actual The actual value to check.
- * @param msg The optional message to include in the error if the assertion fails.
- */
-export declare function assertExists<T>(actual: T, msg?: string): asserts actual is NonNullable<T>;

package/esm/deps/jsr.io/@std/assert/1.0.19/exists.js

@@ -1,27 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-/**
- * Make an assertion that actual is not null or undefined.
- * If not then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertExists } from "@std/assert";
- *
- * assertExists("something"); // Doesn't throw
- * assertExists(undefined); // Throws
- * ```
- *
- * @typeParam T The type of the actual value.
- * @param actual The actual value to check.
- * @param msg The optional message to include in the error if the assertion fails.
- */
-export function assertExists(actual, msg) {
-    if (actual === undefined || actual === null) {
-        const msgSuffix = msg ? `: ${msg}` : ".";
-        msg =
-            `Expected actual: "${actual}" to not be null or undefined${msgSuffix}`;
-        throw new AssertionError(msg);
-    }
-}

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

@@ -1,14 +0,0 @@
-/**
- * Forcefully throws a failed assertion.
- *
- * @example Usage
- * ```ts ignore
- * import { fail } from "@std/assert";
- *
- * fail("Deliberately failed!"); // Throws
- * ```
- *
- * @param msg Optional message to include in the error.
- * @returns Never returns, always throws.
- */
-export declare function fail(msg?: string): never;

package/esm/deps/jsr.io/@std/assert/1.0.19/fail.js

@@ -1,20 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-/**
- * Forcefully throws a failed assertion.
- *
- * @example Usage
- * ```ts ignore
- * import { fail } from "@std/assert";
- *
- * fail("Deliberately failed!"); // Throws
- * ```
- *
- * @param msg Optional message to include in the error.
- * @returns Never returns, always throws.
- */
-export function fail(msg) {
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    throw new AssertionError(`Failed assertion${msgSuffix}`);
-}

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

@@ -1,18 +0,0 @@
-/** Assertion condition for {@linkcode assertFalse}. */
-export type Falsy = false | 0 | 0n | "" | null | undefined;
-/**
- * Make an assertion, an error will be thrown if `expr` has a truthy value.
- *
- * @example Usage
- * ```ts ignore
- * import { assertFalse } from "@std/assert";
- *
- * assertFalse(false); // Doesn't throw
- * assertFalse(true); // Throws
- * ```
- *
- * @param expr The expression to test.
- * @param msg The optional message to display if the assertion fails.
- * @throws {AssertionError} If `expr` is truthy.
- */
-export declare function assertFalse(expr: unknown, msg?: string): asserts expr is Falsy;