@otplib/preset-v11 12.0.0 → 13.0.0

package/LICENSE

@@ -1,6 +1,6 @@
-The MIT License (MIT)
+MIT License
 
-Copyright (c) 2014 Gerald Yeo <contact@fusedthought.com>
+Copyright (c) 2026 Gerald Yeo
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,20 +1,37 @@
 # @otplib/preset-v11
 
-> Preset with v11.x compatibility adapter for otplib@v12.x
+> Drop-in replacement adapter for migrating `otplib` from v11 to v13.
 
-See our [project readme][project-v-readme] for more information
-or visit the [demo website][project-v-site].
+This adapter mimics the v11 API while using v13's plugins under the hood. However, some fundamental changes from v13 may carry over.
 
-## Install
+**Note:** This is intended as a temporary bridge to help you upgrade to v13 without rewriting your entire application immediately. We strongly recommend fully migrating to the new v13 API when possible.
+
+## Installation
 
 ```bash
-npm install --save @otplib/preset-v11
+npm install @otplib/preset-v11
+pnpm add @otplib/preset-v11
+yarn add @otplib/preset-v11
 ```
 
-## License
+## Usage
+
+This package provides a drop-in replacement for `otplib` v11, using the v13 core.
 
-`@otplib/preset-v11` is [MIT licensed][project-license]
+```javascript
+import { authenticator, hotp, totp } from "@otplib/preset-v11";
+
+const secret = authenticator.generateSecret();
+const token = authenticator.generate(secret);
+const isValid = authenticator.check(token, secret);
+```
+
+## Compatibility Notes
+
+- **Epoch**: Uses seconds (UNIX timestamp), same as v11.
+- **Error Handling**: `check` and `verify` methods swallow errors and return `false`, matching v11 behavior.
+- **Secret Length**: Enforces strict secret length (> 16 bytes) due to v13 core security requirements.
+
+## License
 
-[project-license]: https://github.com/yeojz/otplib/blob/master/LICENSE
-[project-v-readme]: https://github.com/yeojz/otplib/blob/master/README.md
-[project-v-site]: https://otplib.yeojz.dev
+[MIT](./LICENSE) © 2026 Gerald Yeo

package/dist/index.cjs

@@ -0,0 +1,411 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Authenticator: () => Authenticator,
+  HOTP: () => HOTP,
+  HashAlgorithms: () => HashAlgorithms,
+  KeyEncodings: () => KeyEncodings,
+  TOTP: () => TOTP,
+  authenticator: () => authenticator,
+  hotp: () => hotp,
+  totp: () => totp
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/authenticator.ts
+var import_core2 = require("@otplib/core");
+var import_plugin_base32_scure3 = require("@otplib/plugin-base32-scure");
+var import_plugin_crypto_noble3 = require("@otplib/plugin-crypto-noble");
+var import_totp2 = require("@otplib/totp");
+
+// src/totp.ts
+var import_plugin_base32_scure2 = require("@otplib/plugin-base32-scure");
+var import_plugin_crypto_noble2 = require("@otplib/plugin-crypto-noble");
+var import_totp = require("@otplib/totp");
+var import_uri2 = require("@otplib/uri");
+
+// src/hotp.ts
+var import_core = require("@otplib/core");
+var import_hotp = require("@otplib/hotp");
+var import_plugin_base32_scure = require("@otplib/plugin-base32-scure");
+var import_plugin_crypto_noble = require("@otplib/plugin-crypto-noble");
+var import_uri = require("@otplib/uri");
+
+// src/types.ts
+var HashAlgorithms = {
+  SHA1: "sha1",
+  SHA256: "sha256",
+  SHA512: "sha512"
+};
+var KeyEncodings = {
+  ASCII: "ascii",
+  HEX: "hex",
+  BASE32: "base32",
+  BASE64: "base64",
+  LATIN1: "latin1",
+  UTF8: "utf8"
+};
+
+// src/hotp.ts
+var defaultCrypto = new import_plugin_crypto_noble.NobleCryptoPlugin();
+var defaultBase32 = new import_plugin_base32_scure.ScureBase32Plugin();
+function secretToBytes(secret, encoding) {
+  if (encoding === KeyEncodings.BASE32 || encoding === "base32") {
+    return defaultBase32.decode(secret);
+  }
+  if (encoding === KeyEncodings.HEX || encoding === "hex") {
+    return (0, import_core.hexToBytes)(secret.replace(/\s/g, ""));
+  }
+  return (0, import_core.stringToBytes)(secret);
+}
+var HOTP = class _HOTP {
+  _options = {};
+  _defaultOptions = {};
+  constructor(defaultOptions = {}) {
+    this._defaultOptions = { ...defaultOptions };
+    this._options = {};
+  }
+  get options() {
+    return { ...this._defaultOptions, ...this._options };
+  }
+  set options(value) {
+    this._options = { ...value };
+  }
+  get defaultOptions() {
+    return this._defaultOptions;
+  }
+  set defaultOptions(value) {
+    this._defaultOptions = value;
+  }
+  get optionsAll() {
+    return this.allOptions();
+  }
+  create(defaultOptions = {}) {
+    return new _HOTP(defaultOptions);
+  }
+  allOptions() {
+    const merged = {
+      algorithm: HashAlgorithms.SHA1,
+      digits: 6,
+      encoding: KeyEncodings.ASCII,
+      crypto: defaultCrypto,
+      base32: defaultBase32,
+      ...this._defaultOptions,
+      ...this._options
+    };
+    return Object.freeze(merged);
+  }
+  resetOptions() {
+    this._options = {};
+    return this;
+  }
+  generate(secret, counter) {
+    const opts = this.allOptions();
+    const secretBytes = secretToBytes(secret, opts.encoding);
+    return (0, import_hotp.generateSync)({
+      secret: secretBytes,
+      counter,
+      algorithm: opts.algorithm,
+      digits: opts.digits,
+      crypto: opts.crypto
+    });
+  }
+  check(token, secret, counter) {
+    const opts = this.allOptions();
+    const secretBytes = secretToBytes(secret, opts.encoding);
+    try {
+      const result = (0, import_hotp.verifySync)({
+        secret: secretBytes,
+        token,
+        counter,
+        algorithm: opts.algorithm,
+        digits: opts.digits,
+        counterTolerance: 0,
+        crypto: opts.crypto
+      });
+      return result.valid;
+    } catch {
+      return false;
+    }
+  }
+  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) {
+    const opts = this.allOptions();
+    return (0, import_uri.generateHOTP)({
+      label: accountName,
+      issuer,
+      secret,
+      algorithm: opts.algorithm,
+      digits: opts.digits,
+      counter
+    });
+  }
+  getClass() {
+    return _HOTP;
+  }
+};
+
+// src/totp.ts
+var defaultCrypto2 = new import_plugin_crypto_noble2.NobleCryptoPlugin();
+var defaultBase322 = new import_plugin_base32_scure2.ScureBase32Plugin();
+function parseWindow(window, step) {
+  if (window === void 0 || window === 0) {
+    return 0;
+  }
+  if (typeof window === "number") {
+    return window * step;
+  }
+  return [window[0] * step, window[1] * step];
+}
+var TOTP = class _TOTP extends HOTP {
+  constructor(defaultOptions = {}) {
+    super(defaultOptions);
+  }
+  create(defaultOptions = {}) {
+    return new _TOTP(defaultOptions);
+  }
+  allOptions() {
+    const merged = {
+      algorithm: HashAlgorithms.SHA1,
+      digits: 6,
+      encoding: KeyEncodings.ASCII,
+      epoch: null,
+      // v11 default was null, meaning "now"
+      step: 30,
+      window: 0,
+      crypto: defaultCrypto2,
+      base32: defaultBase322,
+      ...this._defaultOptions,
+      ...this._options
+    };
+    const epoch = merged.epoch !== null ? merged.epoch : Math.floor(Date.now() / 1e3);
+    return Object.freeze({
+      ...merged,
+      epoch
+    });
+  }
+  generate(secret) {
+    const opts = this.allOptions();
+    const secretBytes = secretToBytes(secret, opts.encoding);
+    return (0, import_totp.generateSync)({
+      secret: secretBytes,
+      algorithm: opts.algorithm,
+      digits: opts.digits,
+      period: opts.step,
+      epoch: opts.epoch,
+      // v11: already in seconds
+      t0: 0,
+      crypto: opts.crypto
+    });
+  }
+  check(token, secret) {
+    const delta = this.checkDelta(token, secret);
+    return typeof delta === "number";
+  }
+  checkDelta(token, secret) {
+    const opts = this.allOptions();
+    const secretBytes = secretToBytes(secret, opts.encoding);
+    const epochTolerance = parseWindow(opts.window, opts.step);
+    try {
+      const result = (0, import_totp.verifySync)({
+        secret: secretBytes,
+        token,
+        algorithm: opts.algorithm,
+        digits: opts.digits,
+        period: opts.step,
+        epoch: opts.epoch,
+        // v11: already in seconds
+        t0: 0,
+        epochTolerance,
+        crypto: opts.crypto
+      });
+      if (!result.valid) {
+        return null;
+      }
+      return result.delta;
+    } catch {
+      return null;
+    }
+  }
+  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);
+  }
+  keyuri(accountName, issuer, secret) {
+    const opts = this.allOptions();
+    return (0, import_uri2.generateTOTP)({
+      label: accountName,
+      issuer,
+      secret,
+      algorithm: opts.algorithm,
+      digits: opts.digits,
+      period: opts.step
+    });
+  }
+  timeUsed() {
+    const opts = this.allOptions();
+    return opts.epoch % opts.step;
+  }
+  timeRemaining() {
+    const opts = this.allOptions();
+    return (0, import_totp.getRemainingTime)(opts.epoch, opts.step, 0);
+  }
+};
+
+// src/authenticator.ts
+var defaultCrypto3 = new import_plugin_crypto_noble3.NobleCryptoPlugin();
+var defaultBase323 = new import_plugin_base32_scure3.ScureBase32Plugin();
+function defaultKeyEncoder(secret, _encoding) {
+  const bytes = new TextEncoder().encode(secret);
+  return defaultBase323.encode(bytes);
+}
+function defaultKeyDecoder(encodedSecret, _encoding) {
+  const bytes = defaultBase323.decode(encodedSecret);
+  return new TextDecoder().decode(bytes);
+}
+function parseWindow2(window, step) {
+  if (window === void 0 || window === 0) {
+    return 0;
+  }
+  if (typeof window === "number") {
+    return window * step;
+  }
+  return [window[0] * step, window[1] * step];
+}
+var Authenticator = class _Authenticator extends TOTP {
+  constructor(defaultOptions = {}) {
+    super(defaultOptions);
+  }
+  create(defaultOptions = {}) {
+    return new _Authenticator(defaultOptions);
+  }
+  allOptions() {
+    const merged = {
+      algorithm: HashAlgorithms.SHA1,
+      digits: 6,
+      encoding: KeyEncodings.HEX,
+      epoch: null,
+      step: 30,
+      window: 0,
+      keyEncoder: defaultKeyEncoder,
+      keyDecoder: defaultKeyDecoder,
+      crypto: defaultCrypto3,
+      base32: defaultBase323,
+      ...this._defaultOptions,
+      ...this._options
+    };
+    const epoch = merged.epoch !== null ? merged.epoch : Math.floor(Date.now() / 1e3);
+    return Object.freeze({
+      ...merged,
+      epoch
+    });
+  }
+  generate(secret) {
+    const opts = this.allOptions();
+    const secretBytes = defaultBase323.decode(secret);
+    return (0, import_totp2.generateSync)({
+      secret: secretBytes,
+      algorithm: opts.algorithm,
+      digits: opts.digits,
+      period: opts.step,
+      epoch: opts.epoch,
+      // v11: already in seconds
+      t0: 0,
+      crypto: opts.crypto
+    });
+  }
+  check(token, secret) {
+    const delta = this.checkDelta(token, secret);
+    return typeof delta === "number";
+  }
+  checkDelta(token, secret) {
+    const opts = this.allOptions();
+    const secretBytes = defaultBase323.decode(secret);
+    const epochTolerance = parseWindow2(opts.window, opts.step);
+    try {
+      const result = (0, import_totp2.verifySync)({
+        secret: secretBytes,
+        token,
+        algorithm: opts.algorithm,
+        digits: opts.digits,
+        period: opts.step,
+        epoch: opts.epoch,
+        // v11: already in seconds
+        t0: 0,
+        epochTolerance,
+        crypto: opts.crypto
+      });
+      if (!result.valid) {
+        return null;
+      }
+      return result.delta;
+    } catch {
+      return null;
+    }
+  }
+  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);
+  }
+  encode(secret) {
+    const opts = this.allOptions();
+    return opts.keyEncoder(secret, opts.encoding);
+  }
+  decode(secret) {
+    const opts = this.allOptions();
+    return opts.keyDecoder(secret, opts.encoding);
+  }
+  generateSecret(numberOfBytes = 20) {
+    const opts = this.allOptions();
+    return (0, import_core2.generateSecret)({
+      crypto: opts.crypto,
+      base32: opts.base32,
+      length: numberOfBytes
+    });
+  }
+};
+
+// src/index.ts
+var hotp = new HOTP();
+var totp = new TOTP();
+var authenticator = new Authenticator();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Authenticator,
+  HOTP,
+  HashAlgorithms,
+  KeyEncodings,
+  TOTP,
+  authenticator,
+  hotp,
+  totp
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/authenticator.ts","../src/totp.ts","../src/hotp.ts","../src/types.ts"],"sourcesContent":["/**\n * @otplib/preset-v11\n *\n * v11 compatibility preset.\n */\n\nimport { Authenticator } from \"./authenticator\";\nimport { HOTP } from \"./hotp\";\nimport { TOTP } from \"./totp\";\n\nexport { HOTP, TOTP, Authenticator };\nexport * from \"./types\";\n\nexport const hotp = new HOTP();\nexport const totp = new TOTP();\nexport const authenticator = new Authenticator();\n","/**\n * @otplib/preset-v11\n *\n * v11-compatible Authenticator class implementation.\n */\n\nimport { generateSecret as generateSecretCore } from \"@otplib/core\";\nimport { ScureBase32Plugin } from \"@otplib/plugin-base32-scure\";\nimport { NobleCryptoPlugin } from \"@otplib/plugin-crypto-noble\";\nimport { generateSync as totpGenerateSync, verifySync as totpVerifySync } from \"@otplib/totp\";\n\nimport { TOTP } from \"./totp\";\nimport { HashAlgorithms, KeyEncodings as KeyEncodingsConst } from \"./types\";\n\nimport type {\n  AuthenticatorOptions,\n  Base32SecretKey,\n  SecretKey,\n  KeyEncodings,\n  ResolvedAuthenticatorOptions,\n} from \"./types\";\nimport type { Digits } from \"@otplib/core\";\n\nconst defaultCrypto = new NobleCryptoPlugin();\nconst defaultBase32 = new ScureBase32Plugin();\n\nfunction defaultKeyEncoder(secret: SecretKey, _encoding: KeyEncodings): Base32SecretKey {\n  const bytes = new TextEncoder().encode(secret);\n  return defaultBase32.encode(bytes);\n}\n\nfunction defaultKeyDecoder(encodedSecret: Base32SecretKey, _encoding: KeyEncodings): SecretKey {\n  const bytes = defaultBase32.decode(encodedSecret);\n  return new TextDecoder().decode(bytes);\n}\n\nfunction parseWindow(\n  window: number | [number, number] | undefined,\n  step: number,\n): number | [number, number] {\n  if (window === undefined || window === 0) {\n    return 0;\n  }\n  if (typeof window === \"number\") {\n    // v11 treated window as steps\n    return window * step;\n  }\n  return [window[0] * step, window[1] * step];\n}\n\nexport class Authenticator<T extends AuthenticatorOptions = AuthenticatorOptions> extends TOTP<T> {\n  constructor(defaultOptions: Partial<T> = {}) {\n    super(defaultOptions);\n  }\n\n  override create(defaultOptions: Partial<T> = {}): Authenticator<T> {\n    return new Authenticator<T>(defaultOptions);\n  }\n\n  override allOptions(): Readonly<ResolvedAuthenticatorOptions> {\n    const merged = {\n      algorithm: HashAlgorithms.SHA1,\n      digits: 6,\n      encoding: KeyEncodingsConst.HEX,\n      epoch: null,\n      step: 30,\n      window: 0,\n      keyEncoder: defaultKeyEncoder,\n      keyDecoder: defaultKeyDecoder,\n      crypto: defaultCrypto,\n      base32: defaultBase32,\n      ...this._defaultOptions,\n      ...this._options,\n    };\n\n    const epoch = merged.epoch !== null ? merged.epoch : Math.floor(Date.now() / 1000);\n\n    return Object.freeze({\n      ...merged,\n      epoch: epoch as number,\n    }) as Readonly<ResolvedAuthenticatorOptions>;\n  }\n\n  override generate(secret: Base32SecretKey): string {\n    const opts = this.allOptions();\n\n    // Generate using decoded secret (as raw bytes)\n    const secretBytes = defaultBase32.decode(secret);\n\n    return totpGenerateSync({\n      secret: secretBytes,\n      algorithm: opts.algorithm,\n      digits: opts.digits as Digits,\n      period: opts.step,\n      epoch: opts.epoch, // v11: already in seconds\n      t0: 0,\n      crypto: opts.crypto,\n    });\n  }\n\n  override check(token: string, secret: Base32SecretKey): boolean {\n    const delta = this.checkDelta(token, secret);\n    return typeof delta === \"number\";\n  }\n\n  override checkDelta(token: string, secret: Base32SecretKey): number | null {\n    const opts = this.allOptions();\n    const secretBytes = defaultBase32.decode(secret);\n    const epochTolerance = parseWindow(opts.window, opts.step);\n\n    try {\n      const result = totpVerifySync({\n        secret: secretBytes,\n        token,\n        algorithm: opts.algorithm,\n        digits: opts.digits as Digits,\n        period: opts.step,\n        epoch: opts.epoch, // v11: already in seconds\n        t0: 0,\n        epochTolerance,\n        crypto: opts.crypto,\n      });\n\n      if (!result.valid) {\n        return null;\n      }\n\n      return result.delta;\n    } catch {\n      return null;\n    }\n  }\n\n  override verify(opts: { token: string; secret: Base32SecretKey }): boolean {\n    if (typeof opts !== \"object\") {\n      // v11 legacy behavior: verify requires object\n      throw new Error(\"Expecting argument 0 of verify to be an object\");\n    }\n    return this.check(opts.token, opts.secret);\n  }\n\n  encode(secret: SecretKey): Base32SecretKey {\n    const opts = this.allOptions();\n    return opts.keyEncoder(secret, opts.encoding);\n  }\n\n  decode(secret: Base32SecretKey): SecretKey {\n    const opts = this.allOptions();\n    return opts.keyDecoder(secret, opts.encoding);\n  }\n\n  generateSecret(numberOfBytes: number = 20): Base32SecretKey {\n    const opts = this.allOptions();\n    return generateSecretCore({\n      crypto: opts.crypto,\n      base32: opts.base32,\n      length: numberOfBytes,\n    });\n  }\n}\n","/**\n * @otplib/preset-v11\n *\n * v11-compatible TOTP class implementation.\n */\n\nimport { ScureBase32Plugin } from \"@otplib/plugin-base32-scure\";\nimport { NobleCryptoPlugin } from \"@otplib/plugin-crypto-noble\";\nimport {\n  generateSync as totpGenerateSync,\n  verifySync as totpVerifySync,\n  getRemainingTime,\n} from \"@otplib/totp\";\nimport { generateTOTP as generateTOTPURI } from \"@otplib/uri\";\n\nimport { HOTP, secretToBytes } from \"./hotp\";\nimport { HashAlgorithms, KeyEncodings as KeyEncodingsConst } from \"./types\";\n\nimport type { TOTPOptions, SecretKey, ResolvedTOTPOptions } from \"./types\";\nimport type { Digits } from \"@otplib/core\";\n\nconst defaultCrypto = new NobleCryptoPlugin();\nconst defaultBase32 = new ScureBase32Plugin();\n\nfunction parseWindow(\n  window: number | [number, number] | undefined,\n  step: number,\n): number | [number, number] {\n  if (window === undefined || window === 0) {\n    return 0;\n  }\n  if (typeof window === \"number\") {\n    // v11 treated window as steps\n    return window * step;\n  }\n  return [window[0] * step, window[1] * step];\n}\n\nexport class TOTP<T extends TOTPOptions = TOTPOptions> extends HOTP<T> {\n  constructor(defaultOptions: Partial<T> = {}) {\n    super(defaultOptions);\n  }\n\n  override create(defaultOptions: Partial<T> = {}): TOTP<T> {\n    return new TOTP<T>(defaultOptions);\n  }\n\n  override allOptions(): Readonly<ResolvedTOTPOptions> {\n    const merged = {\n      algorithm: HashAlgorithms.SHA1,\n      digits: 6,\n      encoding: KeyEncodingsConst.ASCII,\n      epoch: null, // v11 default was null, meaning \"now\"\n      step: 30,\n      window: 0,\n      crypto: defaultCrypto,\n      base32: defaultBase32,\n      ...this._defaultOptions,\n      ...this._options,\n    };\n\n    // Resolve epoch to seconds if null\n    const epoch = merged.epoch !== null ? merged.epoch : Math.floor(Date.now() / 1000);\n\n    return Object.freeze({\n      ...merged,\n      epoch: epoch as number,\n    }) as Readonly<ResolvedTOTPOptions>;\n  }\n\n  generate(secret: SecretKey): string {\n    const opts = this.allOptions();\n    const secretBytes = secretToBytes(secret, opts.encoding);\n\n    return totpGenerateSync({\n      secret: secretBytes,\n      algorithm: opts.algorithm,\n      digits: opts.digits as Digits,\n      period: opts.step,\n      epoch: opts.epoch, // v11: already in seconds\n      t0: 0,\n      crypto: opts.crypto,\n    });\n  }\n\n  check(token: string, secret: SecretKey): boolean {\n    const delta = this.checkDelta(token, secret);\n    return typeof delta === \"number\";\n  }\n\n  checkDelta(token: string, secret: SecretKey): number | null {\n    const opts = this.allOptions();\n    const secretBytes = secretToBytes(secret, opts.encoding);\n    const epochTolerance = parseWindow(opts.window, opts.step);\n\n    try {\n      const result = totpVerifySync({\n        secret: secretBytes,\n        token,\n        algorithm: opts.algorithm,\n        digits: opts.digits as Digits,\n        period: opts.step,\n        epoch: opts.epoch, // v11: already in seconds\n        t0: 0,\n        epochTolerance,\n        crypto: opts.crypto,\n      });\n\n      if (!result.valid) {\n        return null;\n      }\n\n      return result.delta;\n    } catch {\n      return null;\n    }\n  }\n\n  override verify(opts: { token: string; secret: SecretKey }): boolean {\n    if (typeof opts !== \"object\") {\n      throw new Error(\"Expecting argument 0 of verify to be an object\");\n    }\n    return this.check(opts.token, opts.secret);\n  }\n\n  keyuri(accountName: string, issuer: string, secret: SecretKey): string {\n    const opts = this.allOptions();\n\n    return generateTOTPURI({\n      label: accountName,\n      issuer,\n      secret,\n      algorithm: opts.algorithm,\n      digits: opts.digits as Digits,\n      period: opts.step,\n    });\n  }\n\n  timeUsed(): number {\n    const opts = this.allOptions();\n    return opts.epoch % opts.step;\n  }\n\n  timeRemaining(): number {\n    const opts = this.allOptions();\n    return getRemainingTime(opts.epoch, opts.step, 0);\n  }\n}\n","/**\n * @otplib/preset-v11\n *\n * v11-compatible HOTP class implementation.\n */\n\nimport { stringToBytes, hexToBytes } from \"@otplib/core\";\nimport { generateSync as hotpGenerateSync, verifySync as hotpVerifySync } from \"@otplib/hotp\";\nimport { ScureBase32Plugin } from \"@otplib/plugin-base32-scure\";\nimport { NobleCryptoPlugin } from \"@otplib/plugin-crypto-noble\";\nimport { generateHOTP as generateHOTPURI } from \"@otplib/uri\";\n\nimport { HashAlgorithms, KeyEncodings as KeyEncodingsConst } from \"./types\";\n\nimport type { HOTPOptions, SecretKey, ResolvedHOTPOptions } from \"./types\";\nimport type { Digits } from \"@otplib/core\";\n\nconst defaultCrypto = new NobleCryptoPlugin();\nconst defaultBase32 = new ScureBase32Plugin();\n\n/**\n * Convert a string secret to bytes based on encoding\n */\nexport function secretToBytes(secret: SecretKey, encoding?: string): Uint8Array {\n  if (encoding === KeyEncodingsConst.BASE32 || encoding === \"base32\") {\n    return defaultBase32.decode(secret);\n  }\n  if (encoding === KeyEncodingsConst.HEX || encoding === \"hex\") {\n    return hexToBytes(secret.replace(/\\s/g, \"\"));\n  }\n  return stringToBytes(secret);\n}\n\nexport class HOTP<T extends HOTPOptions = HOTPOptions> {\n  protected _options: Partial<T> = {};\n  protected _defaultOptions: Partial<T> = {};\n\n  constructor(defaultOptions: Partial<T> = {}) {\n    this._defaultOptions = { ...defaultOptions };\n    this._options = {};\n  }\n\n  get options(): Partial<T> {\n    return { ...this._defaultOptions, ...this._options };\n  }\n\n  set options(value: Partial<T>) {\n    this._options = { ...value };\n  }\n\n  get defaultOptions(): Partial<T> {\n    return this._defaultOptions;\n  }\n\n  set defaultOptions(value: Partial<T>) {\n    this._defaultOptions = value;\n  }\n\n  get optionsAll(): Readonly<ResolvedHOTPOptions> {\n    return this.allOptions();\n  }\n\n  create(defaultOptions: Partial<T> = {}): HOTP<T> {\n    return new HOTP<T>(defaultOptions);\n  }\n\n  allOptions(): Readonly<ResolvedHOTPOptions> {\n    const merged = {\n      algorithm: HashAlgorithms.SHA1,\n      digits: 6,\n      encoding: KeyEncodingsConst.ASCII,\n      crypto: defaultCrypto,\n      base32: defaultBase32,\n      ...this._defaultOptions,\n      ...this._options,\n    };\n    return Object.freeze(merged) as Readonly<ResolvedHOTPOptions>;\n  }\n\n  resetOptions(): this {\n    this._options = {};\n    return this;\n  }\n\n  generate(secret: SecretKey, counter: number): string {\n    const opts = this.allOptions();\n    const secretBytes = secretToBytes(secret, opts.encoding);\n\n    return hotpGenerateSync({\n      secret: secretBytes,\n      counter,\n      algorithm: opts.algorithm,\n      digits: opts.digits as Digits,\n      crypto: opts.crypto,\n    });\n  }\n\n  check(token: string, secret: SecretKey, counter: number): boolean {\n    const opts = this.allOptions();\n    const secretBytes = secretToBytes(secret, opts.encoding);\n\n    try {\n      const result = hotpVerifySync({\n        secret: secretBytes,\n        token,\n        counter,\n        algorithm: opts.algorithm,\n        digits: opts.digits as Digits,\n        counterTolerance: 0,\n        crypto: opts.crypto,\n      });\n\n      return result.valid;\n    } catch {\n      return false;\n    }\n  }\n\n  verify(opts: { token: string; secret: SecretKey; counter: number }): boolean {\n    if (typeof opts !== \"object\") {\n      throw new Error(\"Expecting argument 0 of verify to be an object\");\n    }\n    return this.check(opts.token, opts.secret, opts.counter);\n  }\n\n  keyuri(accountName: string, issuer: string, secret: SecretKey, counter: number): string {\n    const opts = this.allOptions();\n\n    return generateHOTPURI({\n      label: accountName,\n      issuer,\n      secret,\n      algorithm: opts.algorithm,\n      digits: opts.digits as Digits,\n      counter,\n    });\n  }\n\n  getClass(): typeof HOTP {\n    return HOTP;\n  }\n}\n","/**\n * @otplib/preset-v11\n *\n * v11-compatible type definitions.\n * v11 used functionality similar to v12 but with seconds-based epochs.\n */\n\nimport type { CryptoPlugin, Base32Plugin, HashAlgorithm } from \"@otplib/core\";\n\nexport const HashAlgorithms = {\n  SHA1: \"sha1\",\n  SHA256: \"sha256\",\n  SHA512: \"sha512\",\n} as const;\n\nexport type HashAlgorithms = (typeof HashAlgorithms)[keyof typeof HashAlgorithms];\n\nexport const KeyEncodings = {\n  ASCII: \"ascii\",\n  HEX: \"hex\",\n  BASE32: \"base32\",\n  BASE64: \"base64\",\n  LATIN1: \"latin1\",\n  UTF8: \"utf8\",\n} as const;\n\nexport type KeyEncodings = (typeof KeyEncodings)[keyof typeof KeyEncodings];\n\nexport type SecretKey = string;\nexport type Base32SecretKey = string;\n\nexport type HOTPOptions = {\n  algorithm?: HashAlgorithm;\n  digits?: number;\n  encoding?: KeyEncodings;\n  crypto?: CryptoPlugin;\n  base32?: Base32Plugin;\n};\n\nexport type TOTPOptions = HOTPOptions & {\n  epoch?: number | null; // v11: seconds\n  step?: number;\n  window?: number | [number, number];\n};\n\nexport type KeyEncoder = (secret: SecretKey, encoding: KeyEncodings) => Base32SecretKey;\nexport type KeyDecoder = (encodedSecret: Base32SecretKey, encoding: KeyEncodings) => SecretKey;\n\nexport type AuthenticatorOptions = TOTPOptions & {\n  keyEncoder?: KeyEncoder;\n  keyDecoder?: KeyDecoder;\n};\n\nexport type ResolvedHOTPOptions = {\n  algorithm: HashAlgorithm;\n  digits: number;\n  encoding: KeyEncodings;\n  crypto: CryptoPlugin;\n  base32: Base32Plugin;\n};\n\nexport type ResolvedTOTPOptions = ResolvedHOTPOptions & {\n  epoch: number;\n  step: number;\n  window: number | [number, number];\n};\n\nexport type ResolvedAuthenticatorOptions = ResolvedTOTPOptions & {\n  keyEncoder: KeyEncoder;\n  keyDecoder: KeyDecoder;\n};\n"],"mappings":"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","names":["import_core","import_plugin_base32_scure","import_plugin_crypto_noble","import_totp","import_plugin_base32_scure","import_plugin_crypto_noble","import_uri","hotpGenerateSync","hotpVerifySync","generateHOTPURI","defaultCrypto","defaultBase32","totpGenerateSync","totpVerifySync","generateTOTPURI","defaultCrypto","defaultBase32","parseWindow","totpGenerateSync","totpVerifySync","generateSecretCore"]}

package/dist/index.d.cts

@@ -0,0 +1,139 @@
+import { HashAlgorithm, CryptoPlugin, Base32Plugin } from '@otplib/core';
+
+/**
+ * @otplib/preset-v11
+ *
+ * v11-compatible type definitions.
+ * v11 used functionality similar to v12 but with seconds-based epochs.
+ */
+
+declare const HashAlgorithms: {
+    readonly SHA1: "sha1";
+    readonly SHA256: "sha256";
+    readonly SHA512: "sha512";
+};
+type HashAlgorithms = (typeof HashAlgorithms)[keyof typeof HashAlgorithms];
+declare const KeyEncodings: {
+    readonly ASCII: "ascii";
+    readonly HEX: "hex";
+    readonly BASE32: "base32";
+    readonly BASE64: "base64";
+    readonly LATIN1: "latin1";
+    readonly UTF8: "utf8";
+};
+type KeyEncodings = (typeof KeyEncodings)[keyof typeof KeyEncodings];
+type SecretKey = string;
+type Base32SecretKey = string;
+type HOTPOptions = {
+    algorithm?: HashAlgorithm;
+    digits?: number;
+    encoding?: KeyEncodings;
+    crypto?: CryptoPlugin;
+    base32?: Base32Plugin;
+};
+type TOTPOptions = HOTPOptions & {
+    epoch?: number | null;
+    step?: number;
+    window?: number | [number, number];
+};
+type KeyEncoder = (secret: SecretKey, encoding: KeyEncodings) => Base32SecretKey;
+type KeyDecoder = (encodedSecret: Base32SecretKey, encoding: KeyEncodings) => SecretKey;
+type AuthenticatorOptions = TOTPOptions & {
+    keyEncoder?: KeyEncoder;
+    keyDecoder?: KeyDecoder;
+};
+type ResolvedHOTPOptions = {
+    algorithm: HashAlgorithm;
+    digits: number;
+    encoding: KeyEncodings;
+    crypto: CryptoPlugin;
+    base32: Base32Plugin;
+};
+type ResolvedTOTPOptions = ResolvedHOTPOptions & {
+    epoch: number;
+    step: number;
+    window: number | [number, number];
+};
+type ResolvedAuthenticatorOptions = ResolvedTOTPOptions & {
+    keyEncoder: KeyEncoder;
+    keyDecoder: KeyDecoder;
+};
+
+/**
+ * @otplib/preset-v11
+ *
+ * v11-compatible HOTP class implementation.
+ */
+
+declare class HOTP<T extends HOTPOptions = HOTPOptions> {
+    protected _options: Partial<T>;
+    protected _defaultOptions: Partial<T>;
+    constructor(defaultOptions?: Partial<T>);
+    get options(): Partial<T>;
+    set options(value: Partial<T>);
+    get defaultOptions(): Partial<T>;
+    set defaultOptions(value: Partial<T>);
+    get optionsAll(): Readonly<ResolvedHOTPOptions>;
+    create(defaultOptions?: Partial<T>): HOTP<T>;
+    allOptions(): Readonly<ResolvedHOTPOptions>;
+    resetOptions(): this;
+    generate(secret: SecretKey, counter: number): string;
+    check(token: string, secret: SecretKey, counter: number): boolean;
+    verify(opts: {
+        token: string;
+        secret: SecretKey;
+        counter: number;
+    }): boolean;
+    keyuri(accountName: string, issuer: string, secret: SecretKey, counter: number): string;
+    getClass(): typeof HOTP;
+}
+
+/**
+ * @otplib/preset-v11
+ *
+ * v11-compatible TOTP class implementation.
+ */
+
+declare class TOTP<T extends TOTPOptions = TOTPOptions> extends HOTP<T> {
+    constructor(defaultOptions?: Partial<T>);
+    create(defaultOptions?: Partial<T>): TOTP<T>;
+    allOptions(): Readonly<ResolvedTOTPOptions>;
+    generate(secret: SecretKey): string;
+    check(token: string, secret: SecretKey): boolean;
+    checkDelta(token: string, secret: SecretKey): number | null;
+    verify(opts: {
+        token: string;
+        secret: SecretKey;
+    }): boolean;
+    keyuri(accountName: string, issuer: string, secret: SecretKey): string;
+    timeUsed(): number;
+    timeRemaining(): number;
+}
+
+/**
+ * @otplib/preset-v11
+ *
+ * v11-compatible Authenticator class implementation.
+ */
+
+declare class Authenticator<T extends AuthenticatorOptions = AuthenticatorOptions> extends TOTP<T> {
+    constructor(defaultOptions?: Partial<T>);
+    create(defaultOptions?: Partial<T>): Authenticator<T>;
+    allOptions(): Readonly<ResolvedAuthenticatorOptions>;
+    generate(secret: Base32SecretKey): string;
+    check(token: string, secret: Base32SecretKey): boolean;
+    checkDelta(token: string, secret: Base32SecretKey): number | null;
+    verify(opts: {
+        token: string;
+        secret: Base32SecretKey;
+    }): boolean;
+    encode(secret: SecretKey): Base32SecretKey;
+    decode(secret: Base32SecretKey): SecretKey;
+    generateSecret(numberOfBytes?: number): Base32SecretKey;
+}
+
+declare const hotp: HOTP<HOTPOptions>;
+declare const totp: TOTP<TOTPOptions>;
+declare const authenticator: Authenticator<AuthenticatorOptions>;
+
+export { Authenticator, type AuthenticatorOptions, type Base32SecretKey, HOTP, type HOTPOptions, HashAlgorithms, type KeyDecoder, type KeyEncoder, KeyEncodings, type ResolvedAuthenticatorOptions, type ResolvedHOTPOptions, type ResolvedTOTPOptions, type SecretKey, TOTP, type TOTPOptions, authenticator, hotp, totp };