@dev-blinq/bvt-playwright-js 1.0.0-dev.1

package/otpauth.node-k0uQ9qOV.mjs

@@ -0,0 +1,685 @@
+import * as crypto$1 from "node:crypto";
+
+//#region ../../node_modules/otpauth/dist/otpauth.node.mjs
+//! otpauth 9.5.0 | (c) Héctor Molinero Fernández | MIT | https://github.com/hectorm/otpauth
+/**
+* Converts an integer to an Uint8Array.
+* @param {number} num Integer.
+* @returns {Uint8Array} Uint8Array.
+*/ const uintDecode = (num) => {
+	const buf = /* @__PURE__ */ new ArrayBuffer(8);
+	const arr = new Uint8Array(buf);
+	let acc = num;
+	for (let i = 7; i >= 0; i--) {
+		if (acc === 0) break;
+		arr[i] = acc & 255;
+		acc -= arr[i];
+		acc /= 256;
+	}
+	return arr;
+};
+/**
+* "globalThis" ponyfill.
+* @see [A horrifying globalThis polyfill in universal JavaScript](https://mathiasbynens.be/notes/globalthis)
+* @type {Object.<string, *>}
+*/ const globalScope = (() => {
+	if (typeof globalThis === "object") return globalThis;
+	else {
+		Object.defineProperty(Object.prototype, "__GLOBALTHIS__", {
+			get() {
+				return this;
+			},
+			configurable: true
+		});
+		try {
+			if (typeof __GLOBALTHIS__ !== "undefined") return __GLOBALTHIS__;
+		} finally {
+			delete Object.prototype.__GLOBALTHIS__;
+		}
+	}
+	if (typeof self !== "undefined") return self;
+	else if (typeof window !== "undefined") return window;
+	else if (typeof global !== "undefined") return global;
+})();
+/**
+* Canonicalizes a hash algorithm name.
+* @param {string} algorithm Hash algorithm name.
+* @returns {"SHA1"|"SHA224"|"SHA256"|"SHA384"|"SHA512"|"SHA3-224"|"SHA3-256"|"SHA3-384"|"SHA3-512"} Canonicalized hash algorithm name.
+*/ const canonicalizeAlgorithm = (algorithm) => {
+	switch (true) {
+		case /^(?:SHA-?1|SSL3-SHA1)$/i.test(algorithm): return "SHA1";
+		case /^SHA(?:2?-)?224$/i.test(algorithm): return "SHA224";
+		case /^SHA(?:2?-)?256$/i.test(algorithm): return "SHA256";
+		case /^SHA(?:2?-)?384$/i.test(algorithm): return "SHA384";
+		case /^SHA(?:2?-)?512$/i.test(algorithm): return "SHA512";
+		case /^SHA3-224$/i.test(algorithm): return "SHA3-224";
+		case /^SHA3-256$/i.test(algorithm): return "SHA3-256";
+		case /^SHA3-384$/i.test(algorithm): return "SHA3-384";
+		case /^SHA3-512$/i.test(algorithm): return "SHA3-512";
+		default: throw new TypeError(`Unknown hash algorithm: ${algorithm}`);
+	}
+};
+/**
+* Calculates an HMAC digest.
+* @param {string} algorithm Algorithm.
+* @param {Uint8Array} key Key.
+* @param {Uint8Array} message Message.
+* @returns {Uint8Array} Digest.
+*/ const hmacDigest = (algorithm, key, message) => {
+	if (crypto$1?.createHmac) {
+		const hmac = crypto$1.createHmac(algorithm, globalScope.Buffer.from(key));
+		hmac.update(globalScope.Buffer.from(message));
+		return hmac.digest();
+	} else throw new Error("Missing HMAC function");
+};
+/**
+* RFC 4648 base32 alphabet without pad.
+* @type {string}
+*/ const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+/**
+* Converts a base32 string to an Uint8Array (RFC 4648).
+* @see [LinusU/base32-decode](https://github.com/LinusU/base32-decode)
+* @param {string} str Base32 string.
+* @returns {Uint8Array} Uint8Array.
+*/ const base32Decode = (str) => {
+	str = str.replace(/ /g, "");
+	let end = str.length;
+	while (str[end - 1] === "=") --end;
+	str = (end < str.length ? str.substring(0, end) : str).toUpperCase();
+	const buf = /* @__PURE__ */ new ArrayBuffer(str.length * 5 / 8 | 0);
+	const arr = new Uint8Array(buf);
+	let bits = 0;
+	let value = 0;
+	let index = 0;
+	for (let i = 0; i < str.length; i++) {
+		const idx = ALPHABET.indexOf(str[i]);
+		if (idx === -1) throw new TypeError(`Invalid character found: ${str[i]}`);
+		value = value << 5 | idx;
+		bits += 5;
+		if (bits >= 8) {
+			bits -= 8;
+			arr[index++] = value >>> bits;
+		}
+	}
+	return arr;
+};
+/**
+* Converts an Uint8Array to a base32 string (RFC 4648).
+* @see [LinusU/base32-encode](https://github.com/LinusU/base32-encode)
+* @param {Uint8Array} arr Uint8Array.
+* @returns {string} Base32 string.
+*/ const base32Encode = (arr) => {
+	let bits = 0;
+	let value = 0;
+	let str = "";
+	for (let i = 0; i < arr.length; i++) {
+		value = value << 8 | arr[i];
+		bits += 8;
+		while (bits >= 5) {
+			str += ALPHABET[value >>> bits - 5 & 31];
+			bits -= 5;
+		}
+	}
+	if (bits > 0) str += ALPHABET[value << 5 - bits & 31];
+	return str;
+};
+/**
+* Converts a hexadecimal string to an Uint8Array.
+* @param {string} str Hexadecimal string.
+* @returns {Uint8Array} Uint8Array.
+*/ const hexDecode = (str) => {
+	str = str.replace(/ /g, "");
+	const buf = /* @__PURE__ */ new ArrayBuffer(str.length / 2);
+	const arr = new Uint8Array(buf);
+	for (let i = 0; i < str.length; i += 2) arr[i / 2] = parseInt(str.substring(i, i + 2), 16);
+	return arr;
+};
+/**
+* Converts an Uint8Array to a hexadecimal string.
+* @param {Uint8Array} arr Uint8Array.
+* @returns {string} Hexadecimal string.
+*/ const hexEncode = (arr) => {
+	let str = "";
+	for (let i = 0; i < arr.length; i++) {
+		const hex = arr[i].toString(16);
+		if (hex.length === 1) str += "0";
+		str += hex;
+	}
+	return str.toUpperCase();
+};
+/**
+* Converts a Latin-1 string to an Uint8Array.
+* @param {string} str Latin-1 string.
+* @returns {Uint8Array} Uint8Array.
+*/ const latin1Decode = (str) => {
+	const buf = new ArrayBuffer(str.length);
+	const arr = new Uint8Array(buf);
+	for (let i = 0; i < str.length; i++) arr[i] = str.charCodeAt(i) & 255;
+	return arr;
+};
+/**
+* Converts an Uint8Array to a Latin-1 string.
+* @param {Uint8Array} arr Uint8Array.
+* @returns {string} Latin-1 string.
+*/ const latin1Encode = (arr) => {
+	let str = "";
+	for (let i = 0; i < arr.length; i++) str += String.fromCharCode(arr[i]);
+	return str;
+};
+/**
+* TextEncoder instance.
+* @type {TextEncoder|null}
+*/ const ENCODER = globalScope.TextEncoder ? new globalScope.TextEncoder() : null;
+/**
+* TextDecoder instance.
+* @type {TextDecoder|null}
+*/ const DECODER = globalScope.TextDecoder ? new globalScope.TextDecoder() : null;
+/**
+* Converts an UTF-8 string to an Uint8Array.
+* @param {string} str String.
+* @returns {Uint8Array} Uint8Array.
+*/ const utf8Decode = (str) => {
+	if (!ENCODER) throw new Error("Encoding API not available");
+	return ENCODER.encode(str);
+};
+/**
+* Converts an Uint8Array to an UTF-8 string.
+* @param {Uint8Array} arr Uint8Array.
+* @returns {string} String.
+*/ const utf8Encode = (arr) => {
+	if (!DECODER) throw new Error("Encoding API not available");
+	return DECODER.decode(arr);
+};
+/**
+* Returns random bytes.
+* @param {number} size Size.
+* @returns {Uint8Array} Random bytes.
+*/ const randomBytes = (size) => {
+	if (crypto$1?.randomBytes) return crypto$1.randomBytes(size);
+	else if (globalScope.crypto?.getRandomValues) return globalScope.crypto.getRandomValues(new Uint8Array(size));
+	else throw new Error("Cryptography API not available");
+};
+/**
+* OTP secret key.
+*/ var Secret = class Secret {
+	/**
+	* Converts a Latin-1 string to a Secret object.
+	* @param {string} str Latin-1 string.
+	* @returns {Secret} Secret object.
+	*/ static fromLatin1(str) {
+		return new Secret({ buffer: latin1Decode(str).buffer });
+	}
+	/**
+	* Converts an UTF-8 string to a Secret object.
+	* @param {string} str UTF-8 string.
+	* @returns {Secret} Secret object.
+	*/ static fromUTF8(str) {
+		return new Secret({ buffer: utf8Decode(str).buffer });
+	}
+	/**
+	* Converts a base32 string to a Secret object.
+	* @param {string} str Base32 string.
+	* @returns {Secret} Secret object.
+	*/ static fromBase32(str) {
+		return new Secret({ buffer: base32Decode(str).buffer });
+	}
+	/**
+	* Converts a hexadecimal string to a Secret object.
+	* @param {string} str Hexadecimal string.
+	* @returns {Secret} Secret object.
+	*/ static fromHex(str) {
+		return new Secret({ buffer: hexDecode(str).buffer });
+	}
+	/**
+	* Secret key buffer.
+	* @deprecated For backward compatibility, the "bytes" property should be used instead.
+	* @type {ArrayBufferLike}
+	*/ get buffer() {
+		return this.bytes.buffer;
+	}
+	/**
+	* Latin-1 string representation of secret key.
+	* @type {string}
+	*/ get latin1() {
+		Object.defineProperty(this, "latin1", {
+			enumerable: true,
+			writable: false,
+			configurable: false,
+			value: latin1Encode(this.bytes)
+		});
+		return this.latin1;
+	}
+	/**
+	* UTF-8 string representation of secret key.
+	* @type {string}
+	*/ get utf8() {
+		Object.defineProperty(this, "utf8", {
+			enumerable: true,
+			writable: false,
+			configurable: false,
+			value: utf8Encode(this.bytes)
+		});
+		return this.utf8;
+	}
+	/**
+	* Base32 string representation of secret key.
+	* @type {string}
+	*/ get base32() {
+		Object.defineProperty(this, "base32", {
+			enumerable: true,
+			writable: false,
+			configurable: false,
+			value: base32Encode(this.bytes)
+		});
+		return this.base32;
+	}
+	/**
+	* Hexadecimal string representation of secret key.
+	* @type {string}
+	*/ get hex() {
+		Object.defineProperty(this, "hex", {
+			enumerable: true,
+			writable: false,
+			configurable: false,
+			value: hexEncode(this.bytes)
+		});
+		return this.hex;
+	}
+	/**
+	* Creates a secret key object.
+	* @param {Object} [config] Configuration options.
+	* @param {ArrayBufferLike} [config.buffer] Secret key buffer.
+	* @param {number} [config.size=20] Number of random bytes to generate, ignored if 'buffer' is provided.
+	*/ constructor({ buffer, size = 20 } = {}) {
+		/**
+		* Secret key.
+		* @type {Uint8Array}
+		* @readonly
+		*/ this.bytes = typeof buffer === "undefined" ? randomBytes(size) : new Uint8Array(buffer);
+		Object.defineProperty(this, "bytes", {
+			enumerable: true,
+			writable: false,
+			configurable: false,
+			value: this.bytes
+		});
+	}
+};
+/**
+* Returns true if a is equal to b, without leaking timing information that would allow an attacker to guess one of the values.
+* @param {string} a String a.
+* @param {string} b String b.
+* @returns {boolean} Equality result.
+*/ const timingSafeEqual = (a, b) => {
+	if (crypto$1?.timingSafeEqual) return crypto$1.timingSafeEqual(globalScope.Buffer.from(a), globalScope.Buffer.from(b));
+	else {
+		if (a.length !== b.length) throw new TypeError("Input strings must have the same length");
+		let i = -1;
+		let out = 0;
+		while (++i < a.length) out |= a.charCodeAt(i) ^ b.charCodeAt(i);
+		return out === 0;
+	}
+};
+/**
+* HOTP: An HMAC-based One-time Password Algorithm.
+* @see [RFC 4226](https://datatracker.ietf.org/doc/html/rfc4226)
+*/ var HOTP = class HOTP {
+	/**
+	* Default configuration.
+	* @type {{
+	*   issuer: string,
+	*   label: string,
+	*   issuerInLabel: boolean,
+	*   algorithm: string,
+	*   digits: number,
+	*   counter: number
+	*   window: number
+	* }}
+	*/ static get defaults() {
+		return {
+			issuer: "",
+			label: "OTPAuth",
+			issuerInLabel: true,
+			algorithm: "SHA1",
+			digits: 6,
+			counter: 0,
+			window: 1
+		};
+	}
+	/**
+	* Generates an HOTP token.
+	* @param {Object} config Configuration options.
+	* @param {Secret} config.secret Secret key.
+	* @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.
+	* @param {number} [config.digits=6] Token length.
+	* @param {number} [config.counter=0] Counter value.
+	* @param {(algorithm: string, key: Uint8Array, message: Uint8Array) => Uint8Array} [config.hmac] Custom HMAC function.
+	* @returns {string} Token.
+	*/ static generate({ secret, algorithm = HOTP.defaults.algorithm, digits = HOTP.defaults.digits, counter = HOTP.defaults.counter, hmac = hmacDigest }) {
+		const message = uintDecode(counter);
+		const digest = hmac(algorithm, secret.bytes, message);
+		if (!digest?.byteLength || digest.byteLength < 19) throw new TypeError("Return value must be at least 19 bytes");
+		const offset = digest[digest.byteLength - 1] & 15;
+		return (((digest[offset] & 127) << 24 | (digest[offset + 1] & 255) << 16 | (digest[offset + 2] & 255) << 8 | digest[offset + 3] & 255) % 10 ** digits).toString().padStart(digits, "0");
+	}
+	/**
+	* Generates an HOTP token.
+	* @param {Object} [config] Configuration options.
+	* @param {number} [config.counter=this.counter++] Counter value.
+	* @returns {string} Token.
+	*/ generate({ counter = this.counter++ } = {}) {
+		return HOTP.generate({
+			secret: this.secret,
+			algorithm: this.algorithm,
+			digits: this.digits,
+			counter,
+			hmac: this.hmac
+		});
+	}
+	/**
+	* Validates an HOTP token.
+	* @param {Object} config Configuration options.
+	* @param {string} config.token Token value.
+	* @param {Secret} config.secret Secret key.
+	* @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.
+	* @param {number} [config.digits=6] Token length.
+	* @param {number} [config.counter=0] Counter value.
+	* @param {number} [config.window=1] Window of counter values to test.
+	* @param {(algorithm: string, key: Uint8Array, message: Uint8Array) => Uint8Array} [config.hmac] Custom HMAC function.
+	* @returns {number|null} Token delta or null if it is not found in the search window, in which case it should be considered invalid.
+	*/ static validate({ token, secret, algorithm, digits = HOTP.defaults.digits, counter = HOTP.defaults.counter, window = HOTP.defaults.window, hmac = hmacDigest }) {
+		if (token.length !== digits) return null;
+		let delta = null;
+		const check = (i) => {
+			if (timingSafeEqual(token, HOTP.generate({
+				secret,
+				algorithm,
+				digits,
+				counter: i,
+				hmac
+			}))) delta = i - counter;
+		};
+		check(counter);
+		for (let i = 1; i <= window && delta === null; ++i) {
+			check(counter - i);
+			if (delta !== null) break;
+			check(counter + i);
+			if (delta !== null) break;
+		}
+		return delta;
+	}
+	/**
+	* Validates an HOTP token.
+	* @param {Object} config Configuration options.
+	* @param {string} config.token Token value.
+	* @param {number} [config.counter=this.counter] Counter value.
+	* @param {number} [config.window=1] Window of counter values to test.
+	* @returns {number|null} Token delta or null if it is not found in the search window, in which case it should be considered invalid.
+	*/ validate({ token, counter = this.counter, window }) {
+		return HOTP.validate({
+			token,
+			secret: this.secret,
+			algorithm: this.algorithm,
+			digits: this.digits,
+			counter,
+			window,
+			hmac: this.hmac
+		});
+	}
+	/**
+	* Returns a Google Authenticator key URI.
+	* @returns {string} URI.
+	*/ toString() {
+		const e = encodeURIComponent;
+		return `otpauth://hotp/${this.issuer.length > 0 ? this.issuerInLabel ? `${e(this.issuer)}:${e(this.label)}?issuer=${e(this.issuer)}&` : `${e(this.label)}?issuer=${e(this.issuer)}&` : `${e(this.label)}?`}secret=${e(this.secret.base32)}&algorithm=${e(this.algorithm)}&digits=${e(this.digits)}&counter=${e(this.counter)}`;
+	}
+	/**
+	* Creates an HOTP object.
+	* @param {Object} [config] Configuration options.
+	* @param {string} [config.issuer=''] Account provider.
+	* @param {string} [config.label='OTPAuth'] Account label.
+	* @param {boolean} [config.issuerInLabel=true] Include issuer prefix in label.
+	* @param {Secret|string} [config.secret=Secret] Secret key.
+	* @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.
+	* @param {number} [config.digits=6] Token length.
+	* @param {number} [config.counter=0] Initial counter value.
+	* @param {(algorithm: string, key: Uint8Array, message: Uint8Array) => Uint8Array} [config.hmac] Custom HMAC function.
+	*/ constructor({ issuer = HOTP.defaults.issuer, label = HOTP.defaults.label, issuerInLabel = HOTP.defaults.issuerInLabel, secret = new Secret(), algorithm = HOTP.defaults.algorithm, digits = HOTP.defaults.digits, counter = HOTP.defaults.counter, hmac } = {}) {
+		/**
+		* Account provider.
+		* @type {string}
+		*/ this.issuer = issuer;
+		/**
+		* Account label.
+		* @type {string}
+		*/ this.label = label;
+		/**
+		* Include issuer prefix in label.
+		* @type {boolean}
+		*/ this.issuerInLabel = issuerInLabel;
+		/**
+		* Secret key.
+		* @type {Secret}
+		*/ this.secret = typeof secret === "string" ? Secret.fromBase32(secret) : secret;
+		/**
+		* HMAC hashing algorithm.
+		* @type {string}
+		*/ this.algorithm = hmac ? algorithm : canonicalizeAlgorithm(algorithm);
+		/**
+		* Token length.
+		* @type {number}
+		*/ this.digits = digits;
+		/**
+		* Initial counter value.
+		* @type {number}
+		*/ this.counter = counter;
+		/**
+		* Custom HMAC function.
+		* @type {((algorithm: string, key: Uint8Array, message: Uint8Array) => Uint8Array)|undefined}
+		*/ this.hmac = hmac;
+	}
+};
+/**
+* TOTP: Time-Based One-Time Password Algorithm.
+* @see [RFC 6238](https://datatracker.ietf.org/doc/html/rfc6238)
+*/ var TOTP = class TOTP {
+	/**
+	* Default configuration.
+	* @type {{
+	*   issuer: string,
+	*   label: string,
+	*   issuerInLabel: boolean,
+	*   algorithm: string,
+	*   digits: number,
+	*   period: number
+	*   window: number
+	* }}
+	*/ static get defaults() {
+		return {
+			issuer: "",
+			label: "OTPAuth",
+			issuerInLabel: true,
+			algorithm: "SHA1",
+			digits: 6,
+			period: 30,
+			window: 1
+		};
+	}
+	/**
+	* Calculates the counter. i.e. the number of periods since timestamp 0.
+	* @param {Object} [config] Configuration options.
+	* @param {number} [config.period=30] Token time-step duration.
+	* @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.
+	* @returns {number} Counter.
+	*/ static counter({ period = TOTP.defaults.period, timestamp = Date.now() } = {}) {
+		return Math.floor(timestamp / 1e3 / period);
+	}
+	/**
+	* Calculates the counter. i.e. the number of periods since timestamp 0.
+	* @param {Object} [config] Configuration options.
+	* @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.
+	* @returns {number} Counter.
+	*/ counter({ timestamp = Date.now() } = {}) {
+		return TOTP.counter({
+			period: this.period,
+			timestamp
+		});
+	}
+	/**
+	* Calculates the remaining time in milliseconds until the next token is generated.
+	* @param {Object} [config] Configuration options.
+	* @param {number} [config.period=30] Token time-step duration.
+	* @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.
+	* @returns {number} counter.
+	*/ static remaining({ period = TOTP.defaults.period, timestamp = Date.now() } = {}) {
+		return period * 1e3 - timestamp % (period * 1e3);
+	}
+	/**
+	* Calculates the remaining time in milliseconds until the next token is generated.
+	* @param {Object} [config] Configuration options.
+	* @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.
+	* @returns {number} counter.
+	*/ remaining({ timestamp = Date.now() } = {}) {
+		return TOTP.remaining({
+			period: this.period,
+			timestamp
+		});
+	}
+	/**
+	* Generates a TOTP token.
+	* @param {Object} config Configuration options.
+	* @param {Secret} config.secret Secret key.
+	* @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.
+	* @param {number} [config.digits=6] Token length.
+	* @param {number} [config.period=30] Token time-step duration.
+	* @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.
+	* @param {(algorithm: string, key: Uint8Array, message: Uint8Array) => Uint8Array} [config.hmac] Custom HMAC function.
+	* @returns {string} Token.
+	*/ static generate({ secret, algorithm, digits, period = TOTP.defaults.period, timestamp = Date.now(), hmac }) {
+		return HOTP.generate({
+			secret,
+			algorithm,
+			digits,
+			counter: TOTP.counter({
+				period,
+				timestamp
+			}),
+			hmac
+		});
+	}
+	/**
+	* Generates a TOTP token.
+	* @param {Object} [config] Configuration options.
+	* @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.
+	* @returns {string} Token.
+	*/ generate({ timestamp = Date.now() } = {}) {
+		return TOTP.generate({
+			secret: this.secret,
+			algorithm: this.algorithm,
+			digits: this.digits,
+			period: this.period,
+			timestamp,
+			hmac: this.hmac
+		});
+	}
+	/**
+	* Validates a TOTP token.
+	* @param {Object} config Configuration options.
+	* @param {string} config.token Token value.
+	* @param {Secret} config.secret Secret key.
+	* @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.
+	* @param {number} [config.digits=6] Token length.
+	* @param {number} [config.period=30] Token time-step duration.
+	* @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.
+	* @param {number} [config.window=1] Window of counter values to test.
+	* @param {(algorithm: string, key: Uint8Array, message: Uint8Array) => Uint8Array} [config.hmac] Custom HMAC function.
+	* @returns {number|null} Token delta or null if it is not found in the search window, in which case it should be considered invalid.
+	*/ static validate({ token, secret, algorithm, digits, period = TOTP.defaults.period, timestamp = Date.now(), window, hmac }) {
+		return HOTP.validate({
+			token,
+			secret,
+			algorithm,
+			digits,
+			counter: TOTP.counter({
+				period,
+				timestamp
+			}),
+			window,
+			hmac
+		});
+	}
+	/**
+	* Validates a TOTP token.
+	* @param {Object} config Configuration options.
+	* @param {string} config.token Token value.
+	* @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.
+	* @param {number} [config.window=1] Window of counter values to test.
+	* @returns {number|null} Token delta or null if it is not found in the search window, in which case it should be considered invalid.
+	*/ validate({ token, timestamp, window }) {
+		return TOTP.validate({
+			token,
+			secret: this.secret,
+			algorithm: this.algorithm,
+			digits: this.digits,
+			period: this.period,
+			timestamp,
+			window,
+			hmac: this.hmac
+		});
+	}
+	/**
+	* Returns a Google Authenticator key URI.
+	* @returns {string} URI.
+	*/ toString() {
+		const e = encodeURIComponent;
+		return `otpauth://totp/${this.issuer.length > 0 ? this.issuerInLabel ? `${e(this.issuer)}:${e(this.label)}?issuer=${e(this.issuer)}&` : `${e(this.label)}?issuer=${e(this.issuer)}&` : `${e(this.label)}?`}secret=${e(this.secret.base32)}&algorithm=${e(this.algorithm)}&digits=${e(this.digits)}&period=${e(this.period)}`;
+	}
+	/**
+	* Creates a TOTP object.
+	* @param {Object} [config] Configuration options.
+	* @param {string} [config.issuer=''] Account provider.
+	* @param {string} [config.label='OTPAuth'] Account label.
+	* @param {boolean} [config.issuerInLabel=true] Include issuer prefix in label.
+	* @param {Secret|string} [config.secret=Secret] Secret key.
+	* @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.
+	* @param {number} [config.digits=6] Token length.
+	* @param {number} [config.period=30] Token time-step duration.
+	* @param {(algorithm: string, key: Uint8Array, message: Uint8Array) => Uint8Array} [config.hmac] Custom HMAC function.
+	*/ constructor({ issuer = TOTP.defaults.issuer, label = TOTP.defaults.label, issuerInLabel = TOTP.defaults.issuerInLabel, secret = new Secret(), algorithm = TOTP.defaults.algorithm, digits = TOTP.defaults.digits, period = TOTP.defaults.period, hmac } = {}) {
+		/**
+		* Account provider.
+		* @type {string}
+		*/ this.issuer = issuer;
+		/**
+		* Account label.
+		* @type {string}
+		*/ this.label = label;
+		/**
+		* Include issuer prefix in label.
+		* @type {boolean}
+		*/ this.issuerInLabel = issuerInLabel;
+		/**
+		* Secret key.
+		* @type {Secret}
+		*/ this.secret = typeof secret === "string" ? Secret.fromBase32(secret) : secret;
+		/**
+		* HMAC hashing algorithm.
+		* @type {string}
+		*/ this.algorithm = hmac ? algorithm : canonicalizeAlgorithm(algorithm);
+		/**
+		* Token length.
+		* @type {number}
+		*/ this.digits = digits;
+		/**
+		* Token time-step duration.
+		* @type {number}
+		*/ this.period = period;
+		/**
+		* Custom HMAC function.
+		* @type {((algorithm: string, key: Uint8Array, message: Uint8Array) => Uint8Array)|undefined}
+		*/ this.hmac = hmac;
+	}
+};
+
+//#endregion
+export { TOTP };
+//# sourceMappingURL=otpauth.node-k0uQ9qOV.mjs.map