@udibo/oauth2 0.14.1 → 0.15.1

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

@@ -1,20 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-/**
- * Use this to stub out methods that will throw when invoked.
- *
- * @example Usage
- * ```ts ignore
- * import { unimplemented } from "@std/assert";
- *
- * unimplemented(); // Throws
- * ```
- *
- * @param msg Optional message to include in the error.
- * @returns Never returns, always throws.
- */
-export function unimplemented(msg) {
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    throw new AssertionError(`Unimplemented${msgSuffix}`);
-}

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

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

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

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

package/esm/deps/jsr.io/@std/async/1.5.0/delay.d.ts

@@ -1,44 +0,0 @@
-/** Options for {@linkcode delay}. */
-export interface DelayOptions {
-    /** Signal used to abort the delay. */
-    signal?: AbortSignal;
-    /** Indicates whether the process should continue to run as long as the timer exists.
-     *
-     * @default {true}
-     */
-    persistent?: boolean;
-}
-/**
- * Resolve a {@linkcode Promise} after a given amount of milliseconds.
- *
- * If the optional signal is aborted before the delay duration, the returned
- * promise rejects with the signal's reason. If no reason is provided to
- * `abort()`, the browser's default `DOMException` with name `"AbortError"` is used.
- *
- * @param ms Duration in milliseconds for how long the delay should last.
- * @param options Additional options.
- *
- * @example Basic usage
- * ```ts no-assert
- * import { delay } from "@std/async/delay";
- *
- * // ...
- * const delayedPromise = delay(100);
- * const result = await delayedPromise;
- * // ...
- * ```
- *
- * @example Disable persistence
- *
- * Setting `persistent` to `false` will allow the process to continue to run as
- * long as the timer exists.
- *
- * ```ts no-assert ignore
- * import { delay } from "@std/async/delay";
- *
- * // ...
- * await delay(100, { persistent: false });
- * // ...
- * ```
- */
-export declare function delay(ms: number, options?: DelayOptions): Promise<void>;

package/esm/deps/jsr.io/@std/async/1.5.0/delay.js

@@ -1,84 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-/**
- * Resolve a {@linkcode Promise} after a given amount of milliseconds.
- *
- * If the optional signal is aborted before the delay duration, the returned
- * promise rejects with the signal's reason. If no reason is provided to
- * `abort()`, the browser's default `DOMException` with name `"AbortError"` is used.
- *
- * @param ms Duration in milliseconds for how long the delay should last.
- * @param options Additional options.
- *
- * @example Basic usage
- * ```ts no-assert
- * import { delay } from "@std/async/delay";
- *
- * // ...
- * const delayedPromise = delay(100);
- * const result = await delayedPromise;
- * // ...
- * ```
- *
- * @example Disable persistence
- *
- * Setting `persistent` to `false` will allow the process to continue to run as
- * long as the timer exists.
- *
- * ```ts no-assert ignore
- * import { delay } from "@std/async/delay";
- *
- * // ...
- * await delay(100, { persistent: false });
- * // ...
- * ```
- */
-export function delay(ms, options = {}) {
-    const { signal, persistent = true } = options;
-    if (signal?.aborted)
-        return Promise.reject(signal.reason);
-    return new Promise((resolve, reject) => {
-        const abort = () => {
-            clearTimeout(+i);
-            reject(signal?.reason);
-        };
-        const done = () => {
-            signal?.removeEventListener("abort", abort);
-            resolve();
-        };
-        const i = setArbitraryLengthTimeout(done, ms);
-        signal?.addEventListener("abort", abort, { once: true });
-        if (persistent === false) {
-            try {
-                Deno.unrefTimer(+i);
-            }
-            catch (error) {
-                if (!(error instanceof ReferenceError)) {
-                    clearTimeout(+i);
-                    throw error;
-                }
-                // deno-lint-ignore no-console
-                console.error("`persistent` option is only available in Deno");
-            }
-        }
-    });
-}
-const I32_MAX = 2 ** 31 - 1;
-function setArbitraryLengthTimeout(callback, delay) {
-    // ensure non-negative integer (but > I32_MAX is OK, even if Infinity)
-    delay = Math.trunc(Math.max(delay, 0) || 0);
-    if (delay <= I32_MAX) {
-        const id = Number(setTimeout(callback, delay));
-        return { valueOf: () => id };
-    }
-    const start = Date.now();
-    let timeoutId;
-    const queueTimeout = () => {
-        const currentDelay = delay - (Date.now() - start);
-        timeoutId = currentDelay > I32_MAX
-            ? Number(setTimeout(queueTimeout, I32_MAX))
-            : Number(setTimeout(callback, currentDelay));
-    };
-    queueTimeout();
-    return { valueOf: () => timeoutId };
-}

package/esm/deps/jsr.io/@std/crypto/1.1.0/timing_safe_equal.d.ts

@@ -1,39 +0,0 @@
-/**
- * When checking the values of cryptographic hashes are equal, default
- * comparisons can be susceptible to timing based attacks, where attacker is
- * able to find out information about the host system by repeatedly checking
- * response times to equality comparisons of values.
- *
- * It is likely some form of timing safe equality will make its way to the
- * WebCrypto standard (see:
- * {@link https://github.com/w3c/webcrypto/issues/270 | w3c/webcrypto#270}), but until
- * that time, `timingSafeEqual()` is provided.
- *
- * Note: This is a best-effort constant-time comparison implemented in
- * JavaScript. The V8 JIT compiler does not provide formal constant-time
- * guarantees, and inputs backed by `SharedArrayBuffer` are susceptible to
- * concurrent modification during comparison.
- *
- * @example Usage
- * ```ts
- * import { timingSafeEqual } from "@std/crypto/timing-safe-equal";
- * import { assert } from "@std/assert";
- *
- * const a = await crypto.subtle.digest(
- *   "SHA-384",
- *   new TextEncoder().encode("hello world"),
- * );
- * const b = await crypto.subtle.digest(
- *   "SHA-384",
- *   new TextEncoder().encode("hello world"),
- * );
- *
- * assert(timingSafeEqual(a, b));
- * ```
- *
- * @param a The first value to compare.
- * @param b The second value to compare.
- * @returns `true` if the values are equal, otherwise `false`.
- * @throws {TypeError} If the byte lengths of the two buffers are not equal.
- */
-export declare function timingSafeEqual(a: ArrayBufferView | ArrayBufferLike, b: ArrayBufferView | ArrayBufferLike): boolean;

package/esm/deps/jsr.io/@std/crypto/1.1.0/timing_safe_equal.js

@@ -1,61 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-function toUint8Array(value) {
-    if (value instanceof Uint8Array) {
-        return value;
-    }
-    return ArrayBuffer.isView(value)
-        ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
-        : new Uint8Array(value);
-}
-/**
- * When checking the values of cryptographic hashes are equal, default
- * comparisons can be susceptible to timing based attacks, where attacker is
- * able to find out information about the host system by repeatedly checking
- * response times to equality comparisons of values.
- *
- * It is likely some form of timing safe equality will make its way to the
- * WebCrypto standard (see:
- * {@link https://github.com/w3c/webcrypto/issues/270 | w3c/webcrypto#270}), but until
- * that time, `timingSafeEqual()` is provided.
- *
- * Note: This is a best-effort constant-time comparison implemented in
- * JavaScript. The V8 JIT compiler does not provide formal constant-time
- * guarantees, and inputs backed by `SharedArrayBuffer` are susceptible to
- * concurrent modification during comparison.
- *
- * @example Usage
- * ```ts
- * import { timingSafeEqual } from "@std/crypto/timing-safe-equal";
- * import { assert } from "@std/assert";
- *
- * const a = await crypto.subtle.digest(
- *   "SHA-384",
- *   new TextEncoder().encode("hello world"),
- * );
- * const b = await crypto.subtle.digest(
- *   "SHA-384",
- *   new TextEncoder().encode("hello world"),
- * );
- *
- * assert(timingSafeEqual(a, b));
- * ```
- *
- * @param a The first value to compare.
- * @param b The second value to compare.
- * @returns `true` if the values are equal, otherwise `false`.
- * @throws {TypeError} If the byte lengths of the two buffers are not equal.
- */
-export function timingSafeEqual(a, b) {
-    if (a.byteLength !== b.byteLength) {
-        throw new TypeError(`Cannot compare buffers of different byte lengths (${a.byteLength} vs ${b.byteLength})`);
-    }
-    const ua = toUint8Array(a);
-    const ub = toUint8Array(b);
-    const length = ua.length;
-    let out = 0;
-    for (let i = 0; i < length; i++) {
-        out |= ua[i] ^ ub[i];
-    }
-    return out === 0;
-}

package/esm/deps/jsr.io/@std/encoding/1.0.11/_common16.d.ts

@@ -1,22 +0,0 @@
-import type { Uint8Array_ } from "./_types.js";
-export type { Uint8Array_ };
-export declare const alphabet: Uint8Array<ArrayBuffer>;
-export declare const rAlphabet: Uint8Array<ArrayBuffer>;
-/**
- * Calculate the output size needed to encode a given input size for
- * {@linkcode encodeIntoHex}.
- *
- * @param originalSize The size of the input buffer.
- * @returns The size of the output buffer.
- *
- * @example Basic Usage
- * ```ts
- * import { assertEquals } from "@std/assert";
- * import { calcSizeHex } from "@std/encoding/unstable-hex";
- *
- * assertEquals(calcSizeHex(1), 2);
- * ```
- */
-export declare function calcSizeHex(originalSize: number): number;
-export declare function encode(buffer: Uint8Array_, i: number, o: number, alphabet: Uint8Array): number;
-export declare function decode(buffer: Uint8Array_, i: number, o: number, alphabet: Uint8Array): number;

package/esm/deps/jsr.io/@std/encoding/1.0.11/_common16.js

@@ -1,51 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-export const alphabet = new TextEncoder().encode("0123456789abcdef");
-export const rAlphabet = new Uint8Array(128).fill(16); // alphabet.Hex.length
-alphabet.forEach((byte, i) => rAlphabet[byte] = i);
-new TextEncoder()
-    .encode("ABCDEF")
-    .forEach((byte, i) => rAlphabet[byte] = i + 10);
-/**
- * Calculate the output size needed to encode a given input size for
- * {@linkcode encodeIntoHex}.
- *
- * @param originalSize The size of the input buffer.
- * @returns The size of the output buffer.
- *
- * @example Basic Usage
- * ```ts
- * import { assertEquals } from "@std/assert";
- * import { calcSizeHex } from "@std/encoding/unstable-hex";
- *
- * assertEquals(calcSizeHex(1), 2);
- * ```
- */
-export function calcSizeHex(originalSize) {
-    return originalSize * 2;
-}
-export function encode(buffer, i, o, alphabet) {
-    for (; i < buffer.length; ++i) {
-        const x = buffer[i];
-        buffer[o++] = alphabet[x >> 4];
-        buffer[o++] = alphabet[x & 0xF];
-    }
-    return o;
-}
-export function decode(buffer, i, o, alphabet) {
-    if ((buffer.length - o) % 2 === 1) {
-        throw new RangeError(`Cannot decode input as hex: Length (${buffer.length - o}) must be divisible by 2`);
-    }
-    i += 1;
-    for (; i < buffer.length; i += 2) {
-        buffer[o++] = (getByte(buffer[i - 1], alphabet) << 4) |
-            getByte(buffer[i], alphabet);
-    }
-    return o;
-}
-function getByte(char, alphabet) {
-    const byte = alphabet[char] ?? 16;
-    if (byte === 16) { // alphabet.Hex.length
-        throw new TypeError(`Cannot decode input as hex: Invalid character (${String.fromCharCode(char)})`);
-    }
-    return byte;
-}

package/esm/deps/jsr.io/@std/encoding/1.0.11/_common32.d.ts

@@ -1,34 +0,0 @@
-import type { Uint8Array_ } from "./_types.js";
-export type { Uint8Array_ };
-export declare const padding: number;
-export declare const alphabet: Record<Base32Alphabet, Uint8Array>;
-export declare const rAlphabet: Record<Base32Alphabet, Uint8Array>;
-/**
- * Options for encoding and decoding base32 strings.
- */
-export interface Base32Options {
-    /** The base32 alphabet. Defaults to "base32" */
-    alphabet?: Base32Alphabet;
-}
-/**
- * The base32 alphabets.
- */
-export type Base32Alphabet = "base32" | "base32hex" | "base32crockford";
-/**
- * Calculate the output size needed to encode a given input size for
- * {@linkcode encodeIntoBase32}.
- *
- * @param rawSize The size of the input buffer.
- * @returns The size of the output buffer.
- *
- * @example Basic Usage
- * ```ts
- * import { assertEquals } from "@std/assert";
- * import { calcSizeBase32 } from "@std/encoding/unstable-base32";
- *
- * assertEquals(calcSizeBase32(1), 8);
- * ```
- */
-export declare function calcSizeBase32(rawSize: number): number;
-export declare function encode(buffer: Uint8Array_, i: number, o: number, alphabet: Uint8Array, padding: number): number;
-export declare function decode(buffer: Uint8Array_, i: number, o: number, alphabet: Uint8Array, padding: number): number;

package/esm/deps/jsr.io/@std/encoding/1.0.11/_common32.js

@@ -1,192 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-export const padding = "=".charCodeAt(0);
-export const alphabet = {
-    base32: new TextEncoder().encode("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"),
-    base32hex: new TextEncoder().encode("0123456789ABCDEFGHIJKLMNOPQRSTUV"),
-    base32crockford: new TextEncoder().encode("0123456789ABCDEFGHJKMNPQRSTVWXYZ"),
-};
-export const rAlphabet = {
-    base32: new Uint8Array(128).fill(32), // alphabet.base32.length
-    base32hex: new Uint8Array(128).fill(32),
-    base32crockford: new Uint8Array(128).fill(32),
-};
-alphabet.base32
-    .forEach((byte, i) => rAlphabet.base32[byte] = i);
-alphabet.base32hex
-    .forEach((byte, i) => rAlphabet.base32hex[byte] = i);
-alphabet.base32crockford
-    .forEach((byte, i) => rAlphabet.base32crockford[byte] = i);
-/**
- * Calculate the output size needed to encode a given input size for
- * {@linkcode encodeIntoBase32}.
- *
- * @param rawSize The size of the input buffer.
- * @returns The size of the output buffer.
- *
- * @example Basic Usage
- * ```ts
- * import { assertEquals } from "@std/assert";
- * import { calcSizeBase32 } from "@std/encoding/unstable-base32";
- *
- * assertEquals(calcSizeBase32(1), 8);
- * ```
- */
-export function calcSizeBase32(rawSize) {
-    return ((rawSize + 4) / 5 | 0) * 8;
-}
-export function encode(buffer, i, o, alphabet, padding) {
-    i += 4;
-    for (; i < buffer.length; i += 5) {
-        let x = (buffer[i - 4] << 16) | (buffer[i - 3] << 8) | buffer[i - 2];
-        buffer[o++] = alphabet[x >> 19];
-        buffer[o++] = alphabet[x >> 14 & 0x1F];
-        buffer[o++] = alphabet[x >> 9 & 0x1F];
-        buffer[o++] = alphabet[x >> 4 & 0x1F];
-        x = (x << 16) | (buffer[i - 1] << 8) | buffer[i];
-        buffer[o++] = alphabet[x >> 15 & 0x1F];
-        buffer[o++] = alphabet[x >> 10 & 0x1F];
-        buffer[o++] = alphabet[x >> 5 & 0x1F];
-        buffer[o++] = alphabet[x & 0x1F];
-    }
-    switch (i) {
-        case buffer.length + 3: {
-            const x = buffer[i - 4] << 16;
-            buffer[o++] = alphabet[x >> 19];
-            buffer[o++] = alphabet[x >> 14 & 0x1F];
-            buffer[o++] = padding;
-            buffer[o++] = padding;
-            buffer[o++] = padding;
-            buffer[o++] = padding;
-            buffer[o++] = padding;
-            buffer[o++] = padding;
-            break;
-        }
-        case buffer.length + 2: {
-            const x = (buffer[i - 4] << 16) | (buffer[i - 3] << 8);
-            buffer[o++] = alphabet[x >> 19];
-            buffer[o++] = alphabet[x >> 14 & 0x1F];
-            buffer[o++] = alphabet[x >> 9 & 0x1F];
-            buffer[o++] = alphabet[x >> 4 & 0x1F];
-            buffer[o++] = padding;
-            buffer[o++] = padding;
-            buffer[o++] = padding;
-            buffer[o++] = padding;
-            break;
-        }
-        case buffer.length + 1: {
-            let x = (buffer[i - 4] << 16) | (buffer[i - 3] << 8) | buffer[i - 2];
-            buffer[o++] = alphabet[x >> 19];
-            buffer[o++] = alphabet[x >> 14 & 0x1F];
-            buffer[o++] = alphabet[x >> 9 & 0x1F];
-            buffer[o++] = alphabet[x >> 4 & 0x1F];
-            x <<= 16;
-            buffer[o++] = alphabet[x >> 15 & 0x1F];
-            buffer[o++] = padding;
-            buffer[o++] = padding;
-            buffer[o++] = padding;
-            break;
-        }
-        case buffer.length: {
-            let x = (buffer[i - 4] << 16) | (buffer[i - 3] << 8) | buffer[i - 2];
-            buffer[o++] = alphabet[x >> 19];
-            buffer[o++] = alphabet[x >> 14 & 0x1F];
-            buffer[o++] = alphabet[x >> 9 & 0x1F];
-            buffer[o++] = alphabet[x >> 4 & 0x1F];
-            x = (x << 16) | (buffer[i - 1] << 8);
-            buffer[o++] = alphabet[x >> 15 & 0x1F];
-            buffer[o++] = alphabet[x >> 10 & 0x1F];
-            buffer[o++] = alphabet[x >> 5 & 0x1F];
-            buffer[o++] = padding;
-            break;
-        }
-    }
-    return o;
-}
-export function decode(buffer, i, o, alphabet, padding) {
-    for (let x = buffer.length - 6; x < buffer.length; ++x) {
-        if (buffer[x] === padding) {
-            for (let y = x + 1; y < buffer.length; ++y) {
-                if (buffer[y] !== padding) {
-                    throw new TypeError(`Cannot decode input as base32: Invalid character (${String.fromCharCode(buffer[y])})`);
-                }
-            }
-            buffer = buffer.subarray(0, x);
-            break;
-        }
-    }
-    switch ((buffer.length - o) % 8) {
-        case 6:
-        case 3:
-        case 1:
-            throw new RangeError(`Cannot decode input as base32: Length (${buffer.length - o}), excluding padding, must not have a remainder of 1, 3, or 6 when divided by 8`);
-    }
-    i += 7;
-    for (; i < buffer.length; i += 8) {
-        let x = (getByte(buffer[i - 7], alphabet) << 19) |
-            (getByte(buffer[i - 6], alphabet) << 14) |
-            (getByte(buffer[i - 5], alphabet) << 9) |
-            (getByte(buffer[i - 4], alphabet) << 4);
-        buffer[o++] = x >> 16;
-        buffer[o++] = x >> 8 & 0xFF;
-        x = (x << 16) |
-            (getByte(buffer[i - 3], alphabet) << 15) |
-            (getByte(buffer[i - 2], alphabet) << 10) |
-            (getByte(buffer[i - 1], alphabet) << 5) |
-            getByte(buffer[i], alphabet);
-        buffer[o++] = x >> 16 & 0xFF;
-        buffer[o++] = x >> 8 & 0xFF;
-        buffer[o++] = x & 0xFF;
-    }
-    switch (i) {
-        case buffer.length + 5: {
-            const x = (getByte(buffer[i - 7], alphabet) << 19) |
-                (getByte(buffer[i - 6], alphabet) << 14);
-            buffer[o++] = x >> 16;
-            break;
-        }
-        case buffer.length + 3: {
-            const x = (getByte(buffer[i - 7], alphabet) << 19) |
-                (getByte(buffer[i - 6], alphabet) << 14) |
-                (getByte(buffer[i - 5], alphabet) << 9) |
-                (getByte(buffer[i - 4], alphabet) << 4);
-            buffer[o++] = x >> 16;
-            buffer[o++] = x >> 8 & 0xFF;
-            break;
-        }
-        case buffer.length + 2: {
-            let x = (getByte(buffer[i - 7], alphabet) << 19) |
-                (getByte(buffer[i - 6], alphabet) << 14) |
-                (getByte(buffer[i - 5], alphabet) << 9) |
-                (getByte(buffer[i - 4], alphabet) << 4);
-            buffer[o++] = x >> 16;
-            buffer[o++] = x >> 8 & 0xFF;
-            x = (x << 16) |
-                (getByte(buffer[i - 3], alphabet) << 15);
-            buffer[o++] = x >> 16 & 0xFF;
-            break;
-        }
-        case buffer.length: {
-            let x = (getByte(buffer[i - 7], alphabet) << 19) |
-                (getByte(buffer[i - 6], alphabet) << 14) |
-                (getByte(buffer[i - 5], alphabet) << 9) |
-                (getByte(buffer[i - 4], alphabet) << 4);
-            buffer[o++] = x >> 16;
-            buffer[o++] = x >> 8 & 0xFF;
-            x = (x << 16) |
-                (getByte(buffer[i - 3], alphabet) << 15) |
-                (getByte(buffer[i - 2], alphabet) << 10) |
-                (getByte(buffer[i - 1], alphabet) << 5);
-            buffer[o++] = x >> 16 & 0xFF;
-            buffer[o++] = x >> 8 & 0xFF;
-            break;
-        }
-    }
-    return o;
-}
-function getByte(char, alphabet) {
-    const byte = alphabet[char] ?? 32;
-    if (byte === 32) { // alphabet.Base32.length
-        throw new TypeError(`Cannot decode input as base32: Invalid character (${String.fromCharCode(char)})`);
-    }
-    return byte;
-}

package/esm/deps/jsr.io/@std/encoding/1.0.11/_common64.d.ts

@@ -1,34 +0,0 @@
-import type { Uint8Array_ } from "./_types.js";
-export type { Uint8Array_ };
-export declare const padding: number;
-export declare const alphabet: Record<Base64Alphabet, Uint8Array>;
-export declare const rAlphabet: Record<Base64Alphabet, Uint8Array>;
-/**
- * Options for encoding and decoding base64 strings.
- */
-export interface Base64Options {
-    /** The base64 alphabet. Defaults to "base64" */
-    alphabet?: Base64Alphabet;
-}
-/**
- * The base64 alphabets.
- */
-export type Base64Alphabet = "base64" | "base64url";
-/**
- * Calculate the output size needed to encode a given input size for
- * {@linkcode encodeIntoBase64}.
- *
- * @param originalSize The size of the input buffer.
- * @returns The size of the output buffer.
- *
- * @example Basic Usage
- * ```ts
- * import { assertEquals } from "@std/assert";
- * import { calcSizeBase64 } from "@std/encoding/unstable-base64";
- *
- * assertEquals(calcSizeBase64(1), 4);
- * ```
- */
-export declare function calcSizeBase64(originalSize: number): number;
-export declare function encode(buffer: Uint8Array_, i: number, o: number, alphabet: Uint8Array, padding: number): number;
-export declare function decode(buffer: Uint8Array_, i: number, o: number, alphabet: Uint8Array, padding: number): number;