otplib 12.0.0-1 → 12.0.1

package/hotp/hotp.d.ts

@@ -1,128 +0,0 @@
-import { CreateDigest, CreateHmacKey, HashAlgorithms, HexString, KeyEncodings, OTP, OTPOptions, SecretKey } from './utils';
-/**
- * Interface for options used in HOTP.
- */
-export interface HOTPOptions<T = string> extends OTPOptions {
-    /**
-     * Creates the digest which token is derived from.
-     */
-    createDigest: CreateDigest<T>;
-    /**
-     * Formats the secret into a HMAC key, applying transformations (like padding) where needed
-     */
-    createHmacKey: CreateHmacKey<T>;
-    /**
-     * The algorithm used for calculating the HMAC.
-     */
-    algorithm: HashAlgorithms;
-    /**
-     * **USE WITH CAUTION:** Given the same digest, the same token will be received.
-     *
-     * This is provided for unique use cases. For example, digest generation might
-     * depend on an async API.
-     */
-    digest?: HexString;
-    /**
-     * The number of digits a token will have. Usually 6 or 8.
-     */
-    digits: number;
-    /**
-     * The encoding that was used on the secret.
-     */
-    encoding: KeyEncodings;
-}
-/**
- * Validates the given [[HOTPOptions]]
- */
-export declare function hotpOptionsValidator<T extends HOTPOptions<unknown> = HOTPOptions<unknown>>(options: Readonly<Partial<T>>): void;
-/**
- * Takes a HOTP secret and derives the HMAC key
- * for use in token generation.
- *
- * @param algorithm - Reference: [[HOTPOptions.algorithm]]
- * @param secret
- * @param encoding - Reference: [[HOTPOptions.encoding]]
- */
-export declare const hotpCreateHmacKey: CreateHmacKey;
-/**
- * Returns the default options for HOTP
- */
-export declare function hotpDefaultOptions<T extends HOTPOptions<unknown> = HOTPOptions<unknown>>(): Partial<T>;
-/**
- * Takes an HOTP Option object and provides presets for
- * some of the missing required HOTP option fields and validates
- * the resultant options.
- */
-export declare function hotpOptions<T extends HOTPOptions<unknown> = HOTPOptions<unknown>>(opt: Readonly<Partial<T>>): Readonly<T>;
-/**
- * Formats a given counter into a string counter.
- */
-export declare function hotpCounter(counter: number): HexString;
-/**
- * Converts a digest to a token of a specified length.
- */
-export declare function hotpDigestToToken(hexDigest: HexString, digits: number): string;
-/**
- * Generates a HMAC-based One-time Token (HOTP)
- *
- * **References**
- *
- * -   http://en.wikipedia.org/wiki/HMAC-based_One-time_Password_Algorithm
- * -   http://tools.ietf.org/html/rfc4226
- *
- * **Note**: If options.digest is provided, it will skip digest generation.
- * Use options.digest with caution. Same digest = Same token.
- *
- * @param secret - Your secret key.
- * @param counter - the OTP counter (usually it's an incremental count)
- * @param options - A HOTPOptions object.
- */
-export declare function hotpToken<T extends HOTPOptions<unknown> = HOTPOptions<unknown>>(secret: SecretKey, counter: number, options: Readonly<T>): string;
-/**
- * Checks the given token against the system generated token.
- *
- * **Note**: Token is valid only if it is a number string
- */
-export declare function hotpCheck<T extends HOTPOptions<unknown> = HOTPOptions<unknown>>(token: string, secret: SecretKey, counter: number, options: Readonly<T>): boolean;
-/**
- * Generates a [keyuri](../#keyuri) from options provided
- * and it's type set to HOTP.
- */
-export declare function hotpKeyuri<T extends HOTPOptions<unknown> = HOTPOptions<unknown>>(accountName: string, issuer: string, secret: SecretKey, counter: number, options: Readonly<T>): string;
-/**
- * A class wrapper containing all HOTP methods.
- */
-export declare class HOTP<T extends HOTPOptions = HOTPOptions> extends OTP<T> {
-    /**
-     * Creates a new instance with all defaultOptions and options reset.
-     */
-    create(defaultOptions?: Partial<T>): HOTP<T>;
-    /**
-     * Returns class options polyfilled with some of
-     * the missing required options.
-     *
-     * Reference: [[hotpOptions]]
-     */
-    allOptions(): Readonly<T>;
-    /**
-     * Reference: [[hotpToken]]
-     */
-    generate(secret: SecretKey, counter: number): string;
-    /**
-     * Reference: [[hotpCheck]]
-     */
-    check(token: string, secret: SecretKey, counter: number): boolean;
-    /**
-     * Same as [[check]] but accepts a single object based argument.
-     */
-    verify(opts: {
-        token: string;
-        secret: SecretKey;
-        counter: number;
-    }): boolean;
-    /**
-     * Calls [keyuri](../#keyuri) with class options and type
-     * set to HOTP.
-     */
-    keyuri(accountName: string, issuer: string, secret: SecretKey, counter: number): string;
-}

package/hotp/index.d.ts

@@ -1,2 +0,0 @@
-export * from './utils';
-export * from './hotp';

package/hotp/index.js

@@ -1,224 +0,0 @@
-/**
- * otplib-hotp
- *
- * @author Gerald Yeo <contact@fusedthought.com>
- * @version: 12.0.0-1
- * @license: MIT
- **/
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function objectValues(value) {
-  return Object.keys(value).map(key => value[key]);
-}
-(function (HashAlgorithms) {
-  HashAlgorithms["SHA1"] = "sha1";
-  HashAlgorithms["SHA256"] = "sha256";
-  HashAlgorithms["SHA512"] = "sha512";
-})(exports.HashAlgorithms || (exports.HashAlgorithms = {}));
-const HASH_ALGORITHMS = objectValues(exports.HashAlgorithms);
-(function (KeyEncodings) {
-  KeyEncodings["ASCII"] = "ascii";
-  KeyEncodings["BASE64"] = "base64";
-  KeyEncodings["HEX"] = "hex";
-  KeyEncodings["LATIN1"] = "latin1";
-  KeyEncodings["UTF8"] = "utf8";
-})(exports.KeyEncodings || (exports.KeyEncodings = {}));
-const KEY_ENCODINGS = objectValues(exports.KeyEncodings);
-(function (Strategy) {
-  Strategy["HOTP"] = "hotp";
-  Strategy["TOTP"] = "totp";
-})(exports.Strategy || (exports.Strategy = {}));
-const STRATEGY = objectValues(exports.Strategy);
-const createDigestPlaceholder = () => {
-  throw new Error('Please provide an options.createDigest implementation.');
-};
-function isTokenValid(value) {
-  return /^(\d+)$/.test(value);
-}
-function padStart(value, maxLength, fillString) {
-  if (value.length >= maxLength) {
-    return value;
-  }
-  const padding = Array(maxLength + 1).join(fillString);
-  return `${padding}${value}`.slice(-1 * maxLength);
-}
-function keyuri(options) {
-  const tmpl = `otpauth://${options.type}/{labelPrefix}:{accountName}?secret={secret}{query}`;
-  const params = [];
-  if (STRATEGY.indexOf(options.type) < 0) {
-    throw new Error(`Expecting options.type to be one of ${STRATEGY.join(', ')}. Received ${options.type}.`);
-  }
-  if (options.type === 'hotp') {
-    if (options.counter == null || typeof options.counter !== 'number') {
-      throw new Error('Expecting options.counter to be a number when options.type is "hotp".');
-    }
-    params.push(`&counter=${options.counter}`);
-  }
-  if (options.type === 'totp' && options.step) {
-    params.push(`&period=${options.step}`);
-  }
-  if (options.digits) {
-    params.push(`&digits=${options.digits}`);
-  }
-  if (options.algorithm) {
-    params.push(`&algorithm=${options.algorithm.toUpperCase()}`);
-  }
-  if (options.issuer) {
-    params.push(`&issuer=${encodeURIComponent(options.issuer)}`);
-  }
-  return tmpl.replace('{labelPrefix}', encodeURIComponent(options.issuer || options.accountName)).replace('{accountName}', encodeURIComponent(options.accountName)).replace('{secret}', options.secret).replace('{query}', params.join(''));
-}
-class OTP {
-  constructor(defaultOptions = {}) {
-    this._defaultOptions = Object.freeze({ ...defaultOptions
-    });
-    this._options = Object.freeze({});
-  }
-  create(defaultOptions = {}) {
-    return new OTP(defaultOptions);
-  }
-  clone(defaultOptions = {}) {
-    const instance = this.create({ ...this._defaultOptions,
-      ...defaultOptions
-    });
-    instance.options = this._options;
-    return instance;
-  }
-  get options() {
-    return Object.freeze({ ...this._defaultOptions,
-      ...this._options
-    });
-  }
-  set options(options) {
-    this._options = Object.freeze({ ...this._options,
-      ...options
-    });
-  }
-  allOptions() {
-    return this.options;
-  }
-  resetOptions() {
-    this._options = Object.freeze({});
-  }
-}
-
-function hotpOptionsValidator(options) {
-  if (typeof options.createDigest !== 'function') {
-    throw new Error('Expecting options.createDigest to be a function.');
-  }
-  if (typeof options.createHmacKey !== 'function') {
-    throw new Error('Expecting options.createHmacKey to be a function.');
-  }
-  if (typeof options.digits !== 'number') {
-    throw new Error('Expecting options.digits to be a number.');
-  }
-  if (!options.algorithm || HASH_ALGORITHMS.indexOf(options.algorithm) < 0) {
-    throw new Error(`Expecting options.algorithm to be one of ${HASH_ALGORITHMS.join(', ')}. Received ${options.algorithm}.`);
-  }
-  if (!options.encoding || KEY_ENCODINGS.indexOf(options.encoding) < 0) {
-    throw new Error(`Expecting options.encoding to be one of ${KEY_ENCODINGS.join(', ')}. Received ${options.encoding}.`);
-  }
-}
-const hotpCreateHmacKey = (algorithm, secret, encoding) => {
-  return Buffer.from(secret, encoding).toString('hex');
-};
-function hotpDefaultOptions() {
-  const options = {
-    algorithm: exports.HashAlgorithms.SHA1,
-    createHmacKey: hotpCreateHmacKey,
-    createDigest: createDigestPlaceholder,
-    digits: 6,
-    encoding: exports.KeyEncodings.ASCII
-  };
-  return options;
-}
-function hotpOptions(opt) {
-  const options = { ...hotpDefaultOptions(),
-    ...opt
-  };
-  hotpOptionsValidator(options);
-  return Object.freeze(options);
-}
-function hotpCounter(counter) {
-  const hexCounter = counter.toString(16);
-  return padStart(hexCounter, 16, '0');
-}
-function hotpDigestToToken(hexDigest, digits) {
-  const digest = Buffer.from(hexDigest, 'hex');
-  const offset = digest[digest.length - 1] & 0xf;
-  const binary = (digest[offset] & 0x7f) << 24 | (digest[offset + 1] & 0xff) << 16 | (digest[offset + 2] & 0xff) << 8 | digest[offset + 3] & 0xff;
-  const token = binary % Math.pow(10, digits);
-  return padStart(String(token), digits, '0');
-}
-function hotpDigest(secret, counter, options) {
-  const hexCounter = hotpCounter(counter);
-  const hmacKey = options.createHmacKey(options.algorithm, secret, options.encoding);
-  return options.createDigest(options.algorithm, hmacKey, hexCounter);
-}
-function hotpToken(secret, counter, options) {
-  const hexDigest = options.digest || hotpDigest(secret, counter, options);
-  return hotpDigestToToken(hexDigest, options.digits);
-}
-function hotpCheck(token, secret, counter, options) {
-  if (!isTokenValid(token)) {
-    return false;
-  }
-  const systemToken = hotpToken(secret, counter, options);
-  return token === systemToken;
-}
-function hotpKeyuri(accountName, issuer, secret, counter, options) {
-  return keyuri({
-    algorithm: options.algorithm,
-    digits: options.digits,
-    type: exports.Strategy.HOTP,
-    accountName,
-    counter,
-    issuer,
-    secret
-  });
-}
-class HOTP extends OTP {
-  create(defaultOptions = {}) {
-    return new HOTP(defaultOptions);
-  }
-  allOptions() {
-    return hotpOptions(this.options);
-  }
-  generate(secret, counter) {
-    return hotpToken(secret, counter, this.allOptions());
-  }
-  check(token, secret, counter) {
-    return hotpCheck(token, secret, counter, this.allOptions());
-  }
-  verify(opts) {
-    if (typeof opts !== 'object') {
-      throw new Error('Expecting argument 0 of verify to be an object');
-    }
-    return this.check(opts.token, opts.secret, opts.counter);
-  }
-  keyuri(accountName, issuer, secret, counter) {
-    return hotpKeyuri(accountName, issuer, secret, counter, this.allOptions());
-  }
-}
-
-exports.HASH_ALGORITHMS = HASH_ALGORITHMS;
-exports.HOTP = HOTP;
-exports.KEY_ENCODINGS = KEY_ENCODINGS;
-exports.OTP = OTP;
-exports.STRATEGY = STRATEGY;
-exports.createDigestPlaceholder = createDigestPlaceholder;
-exports.hotpCheck = hotpCheck;
-exports.hotpCounter = hotpCounter;
-exports.hotpCreateHmacKey = hotpCreateHmacKey;
-exports.hotpDefaultOptions = hotpDefaultOptions;
-exports.hotpDigestToToken = hotpDigestToToken;
-exports.hotpKeyuri = hotpKeyuri;
-exports.hotpOptions = hotpOptions;
-exports.hotpOptionsValidator = hotpOptionsValidator;
-exports.hotpToken = hotpToken;
-exports.isTokenValid = isTokenValid;
-exports.keyuri = keyuri;
-exports.objectValues = objectValues;
-exports.padStart = padStart;

package/hotp/utils.d.ts

@@ -1,208 +0,0 @@
-/**
- * Secret Key used for OTP generation.
- */
-export declare type SecretKey = string;
-/**
- * A hex encoded string.
- */
-export declare type HexString = string;
-/**
- * Base interface for all option interfaces.
- * eg: [[HOTPOptions]].
- */
-export interface OTPOptions {
-    [key: string]: unknown;
-}
-/**
- * Returns an array of values of the enumerable properties of an object.
- * This is used in place of Object.values for wider platform support.
- *
- * @ignore
- *
- * @param value Object that contains the properties and methods.
- */
-export declare function objectValues<T>(value: T): string[];
-/**
- * Algorithms that are available to be used for
- * calculating the HMAC value
- */
-export declare enum HashAlgorithms {
-    'SHA1' = "sha1",
-    'SHA256' = "sha256",
-    'SHA512' = "sha512"
-}
-/**
- * Array of [[HashAlgorithms]] enum values
- *
- * @ignore
- */
-export declare const HASH_ALGORITHMS: string[];
-/**
- * The encoding format for the [[SecretKey]].
- * This is mostly used for converting the
- * provided secret into a Buffer.
- */
-export declare enum KeyEncodings {
-    'ASCII' = "ascii",
-    'BASE64' = "base64",
-    'HEX' = "hex",
-    'LATIN1' = "latin1",
-    'UTF8' = "utf8"
-}
-/**
- * Array of [[KeyEncodings]] enum values
- *
- * @ignore
- */
-export declare const KEY_ENCODINGS: string[];
-/**
- * The OTP generation strategies.
- * Either HMAC or Time based.
- */
-export declare enum Strategy {
-    'HOTP' = "hotp",
-    'TOTP' = "totp"
-}
-/**
- * Array of [[Strategy]] enum values
- *
- * @ignore
- */
-export declare const STRATEGY: string[];
-/**
- * Interface method for formatting the [[SecretKey]] with
- * the algorithm constraints before it is given to [[CreateDigest]].
- */
-export interface CreateHmacKey<T = HexString> {
-    (algorithm: HashAlgorithms, secret: SecretKey, encoding: KeyEncodings): T;
-}
-/**
- * Interface method for generating a HMAC digest
- * which is then used to generate the token.
- */
-export interface CreateDigest<T = HexString> {
-    (algorithm: HashAlgorithms, hmacKey: HexString, counter: HexString): T;
-}
-/**
- * Inteface for options accepted by keyuri
- */
-export interface KeyURIOptions {
-    accountName: string;
-    algorithm?: HashAlgorithms;
-    counter?: number;
-    digits?: number;
-    issuer?: string;
-    label?: string;
-    secret: SecretKey;
-    step?: number;
-    type: Strategy;
-}
-/**
- * createDigest placholder function which throws an error
- * when it is not replaced with an actual implementation.
- *
- * @ignore
- */
-export declare const createDigestPlaceholder: CreateDigest;
-/**
- * Checks if a string contains a valid token format.
- *
- * @param value - a number string.
- */
-export declare function isTokenValid(value: string): boolean;
-/**
- * Left pad the current string with a given string to a given length.
- *
- * This behaves similarly to String.prototype.padStart
- *
- * @ignore
- *
- * @param value The string to pad.
- * @param maxLength The length of the resulting string once the current string has been padded.
- *  If this parameter is smaller than the current string's length, the current
- *  string will be returned as it is.
- * @param fillString The string to pad the current string with.
- */
-export declare function padStart(value: string, maxLength: number, fillString: string): string;
-/**
- * Generates an otpauth uri which can be used in a QR Code.
- *
- * Reference: https://github.com/google/google-authenticator/wiki/Key-Uri-Format
- *
- * Sample Output: otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&issuer=Example
- *
- * **Example**
- *
- * ```js
- * import qrcode from 'qrcode';
- *
- * const otpauth = keyuri({ ... })
- *
- * qrcode.toDataURL(otpauth, (err, imageUrl) => {
- *   if (err) {
- *     console.log('Error with QR');
- *     return;
- *   }
- *   console.log(imageUrl);
- * });
- * ```
- */
-export declare function keyuri(options: KeyURIOptions): string;
-/**
- * Base OTP class which provides options management
- * All OTP classes should be extended from this class.
- */
-export declare class OTP<T extends OTPOptions = OTPOptions> {
-    /**
-     * Default options for an instance.
-     *
-     * These options **WILL PERSIST** even when [[resetOptions]] is called.
-     */
-    protected _defaultOptions: Readonly<Partial<T>>;
-    /**
-     * Transient options for an instance.
-     *
-     * Values set here will take precedence over the same options that
-     * are set in [[_defaultOptions]].
-     *
-     * These options **WILL NOT PERSIST** upon calling [[resetOptions]].
-     */
-    protected _options: Readonly<Partial<T>>;
-    /**
-     * Constructs the class with defaultOptions set.
-     *
-     * @param defaultOptions used to override or add existing defaultOptions.
-     */
-    constructor(defaultOptions?: Partial<T>);
-    /**
-     * Creates a new instance with all defaultOptions and options reset.
-     */
-    create(defaultOptions?: Partial<T>): OTP<T>;
-    /**
-     * Copies the defaultOptions and options from the current
-     * instance and applies the provided defaultOptions.
-     */
-    clone(defaultOptions?: Partial<T>): ReturnType<this['create']>;
-    /**
-     * - The options **getter** will return all [[_options]],
-     * including those set into [[_defaultOptions]].
-     */
-    /**
-    * - The options **setter** sets values into [[_options]].
-    */
-    options: Partial<T>;
-    /**
-     * Returns class options polyfilled with some of
-     * the missing required options.
-     *
-     * Reference: [[hotpOptions]]
-     */
-    allOptions(): Readonly<T>;
-    /**
-     * Resets the current options. Does not reset default options.
-     *
-     * Default options are those that are specified during class
-     * inititialisation, when calling [[clone]] or when calling [[create]]
-     */
-    resetOptions(): void;
-}

package/hotp-async/hotp.d.ts

@@ -1,33 +0,0 @@
-import { HOTPOptions, HexString, OTP, SecretKey } from '../hotp';
-/**
- * Allow HOTPOptions to accept async method options
- */
-export declare type HOTPAsyncOptions = HOTPOptions<Promise<string>>;
-/**
- * Generates the digest for HOTP based tokens.
- * Async version of [[hotpDigest]].
- */
-export declare function hotpDigestAsync<T extends HOTPAsyncOptions = HOTPAsyncOptions>(secret: SecretKey, counter: number, options: Readonly<T>): Promise<HexString>;
-/**
- * Async version of [[hotpToken]].
- */
-export declare function hotpTokenAsync<T extends HOTPAsyncOptions = HOTPAsyncOptions>(secret: SecretKey, counter: number, options: Readonly<T>): Promise<string>;
-/**
- * Async version of [[hotpCheck]].
- */
-export declare function hotpCheckAsync<T extends HOTPAsyncOptions = HOTPAsyncOptions>(token: string, secret: SecretKey, counter: number, options: Readonly<T>): Promise<boolean>;
-/**
- * Async version of [[HOTP]].
- */
-export declare class HOTPAsync<T extends HOTPAsyncOptions = HOTPAsyncOptions> extends OTP<T> {
-    create(defaultOptions?: Partial<T>): HOTPAsync<T>;
-    allOptions(): Readonly<T>;
-    generate(secret: SecretKey, counter: number): Promise<string>;
-    check(token: string, secret: SecretKey, counter: number): Promise<boolean>;
-    verify(opts: {
-        token: string;
-        secret: SecretKey;
-        counter: number;
-    }): Promise<boolean>;
-    keyuri(accountName: string, issuer: string, secret: SecretKey, counter: number): Promise<string>;
-}

package/hotp-async/index.d.ts

@@ -1 +0,0 @@
-export * from './hotp';

package/hotp-async/index.js

@@ -1,55 +0,0 @@
-/**
- * otplib-hotp-async
- *
- * @author Gerald Yeo <contact@fusedthought.com>
- * @version: 12.0.0-1
- * @license: MIT
- **/
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var otplibHotp = require('../hotp');
-
-async function hotpDigestAsync(secret, counter, options) {
-  const hexCounter = otplibHotp.hotpCounter(counter);
-  const hmacKey = await options.createHmacKey(options.algorithm, secret, options.encoding);
-  return options.createDigest(options.algorithm, hmacKey, hexCounter);
-}
-async function hotpTokenAsync(secret, counter, options) {
-  const digest = await hotpDigestAsync(secret, counter, options);
-  return otplibHotp.hotpToken(secret, counter, { ...options,
-    digest
-  });
-}
-async function hotpCheckAsync(token, secret, counter, options) {
-  const digest = await hotpDigestAsync(secret, counter, options);
-  return otplibHotp.hotpCheck(token, secret, counter, { ...options,
-    digest
-  });
-}
-class HOTPAsync extends otplibHotp.OTP {
-  create(defaultOptions = {}) {
-    return new HOTPAsync(defaultOptions);
-  }
-  allOptions() {
-    return otplibHotp.hotpOptions(this.options);
-  }
-  async generate(secret, counter) {
-    return hotpTokenAsync(secret, counter, this.allOptions());
-  }
-  async check(token, secret, counter) {
-    return hotpCheckAsync(token, secret, counter, this.allOptions());
-  }
-  async verify(opts) {
-    return this.check(opts.token, opts.secret, opts.counter);
-  }
-  async keyuri(accountName, issuer, secret, counter) {
-    return otplibHotp.hotpKeyuri(accountName, issuer, secret, counter, this.allOptions());
-  }
-}
-
-exports.HOTPAsync = HOTPAsync;
-exports.hotpCheckAsync = hotpCheckAsync;
-exports.hotpDigestAsync = hotpDigestAsync;
-exports.hotpTokenAsync = hotpTokenAsync;

package/plugin-base32-enc-dec/index.d.ts

@@ -1,9 +0,0 @@
-import { KeyDecoder, KeyEncoder } from '../authenticator';
-/**
- * - Key decoder using npm `base32-decode`
- */
-export declare const keyDecoder: KeyDecoder;
-/**
- * - Key encoder using npm `base32-encode`
- */
-export declare const keyEncoder: KeyEncoder;

package/plugin-base32-enc-dec/index.js

@@ -1,28 +0,0 @@
-/**
- * otplib-plugin-base32-enc-dec
- *
- * @author Gerald Yeo <contact@fusedthought.com>
- * @version: 12.0.0-1
- * @license: MIT
- **/
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-var base32Decode = _interopDefault(require('base32-decode'));
-var base32Encode = _interopDefault(require('base32-encode'));
-
-const keyDecoder = (secret, encoding) => {
-  const arrayBuffer = base32Decode(secret.toUpperCase(), 'RFC4648');
-  return Buffer.from(arrayBuffer).toString(encoding);
-};
-const keyEncoder = (secret, encoding) => {
-  return base32Encode(Buffer.from(secret, encoding), 'RFC4648', {
-    padding: false
-  });
-};
-
-exports.keyDecoder = keyDecoder;
-exports.keyEncoder = keyEncoder;

package/plugin-crypto/index.d.ts

@@ -1,4 +0,0 @@
-import { CreateDigest } from '../hotp';
-import { CreateRandomBytes } from '../authenticator';
-export declare const createDigest: CreateDigest;
-export declare const createRandomBytes: CreateRandomBytes;