@lumjs/encode 2.3.2 → 2.4.1

package/CHANGELOG.md

@@ -6,6 +6,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.4.1] - 2026-02-09
+### Changed
+- Refactored hashifier a bit to make resetting progressive digests simpler.
+- Made all the debugging info in hotp/totp modules optional.
+- Added `expires` to compiled options for totp module; provides the number
+  of seconds until the _current_ code expires.
+- Added a getExpiry() method to totp class that calculates and returns
+  just the current expiry information (useful for countdown displays).
+- Muted an expected error message in a test file.
+- Some other minor cleanups.
+
+## [2.4.0] - 2026-01-19
+### Added
+- A new `pem` module (which exports a `PEM` class) for parsing PEM strings.
+- Tests for the `pem` module.
+- A `str2ta()` function was added to the `util` module.
+### Fixed
+- A fatal error in the `base64.encodeData()` function.
+
 ## [2.3.2] - 2026-01-14
 ### Fixed
 - More things I missed, sigh.
@@ -77,7 +96,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - Initial release.
 
-[Unreleased]: https://github.com/supernovus/lum.encode.js/compare/v2.3.2...HEAD
+[Unreleased]: https://github.com/supernovus/lum.encode.js/compare/v2.4.1...HEAD
+[2.4.1]: https://github.com/supernovus/lum.encode.js/compare/v2.4.0...v2.4.1
+[2.4.0]: https://github.com/supernovus/lum.encode.js/compare/v2.3.2...v2.4.0
 [2.3.2]: https://github.com/supernovus/lum.encode.js/compare/v2.3.1...v2.3.2
 [2.3.1]: https://github.com/supernovus/lum.encode.js/compare/v2.3.0...v2.3.1
 [2.3.0]: https://github.com/supernovus/lum.encode.js/compare/v2.2.2...v2.3.0

package/lib/base64.js

@@ -1,5 +1,5 @@
 
-const {S,B,F,isObj} = require('@lumjs/core/types');
+const { isObj } = require('@lumjs/core/types');
 
 const D_MIME = 'application/octet-stream';
 const D_ENC  = 'utf-8';
@@ -8,7 +8,7 @@ const P_B64  = ';base64,';
 const R_PRE  = /^data\:(.*?);base64,/;
 const B_64U  = 'base64url';
 
-const UI8_FB64  = (typeof Uint8Array.fromBase64 === F);
+const UI8_FB64  = (typeof Uint8Array.fromBase64 === 'function');
 const URL_CHARS = /_-/;
 
 /**
@@ -103,7 +103,7 @@ function toBytes(base64, options={})
  */
 function fromBytes(bytes, options={})
 {
-  if (typeof bytes.toBase64 === F)
+  if (typeof bytes.toBase64 === 'function')
   {
     return bytes.toBase64(options);
   }
@@ -139,7 +139,7 @@ function fromBytes(bytes, options={})
  */
 function encodeText(data, options={})
 {
-  if (typeof options === B) 
+  if (typeof options === 'boolean') 
   { // Assume the 'url' option.
     options = {url: options};
   }
@@ -149,15 +149,15 @@ function encodeText(data, options={})
     const encoder = new TextEncoder();
     data = encoder.encode(data);
   }
-  const toB64 = (typeof data.toBase64 === F);
+  const toB64 = (typeof data.toBase64 === 'function');
 
   if (toB64 && options.url)
   {
-    if (typeof options.alphabet !== S)
+    if (typeof options.alphabet !== 'string')
     {
       options.alphabet = B_64U;
     }
-    if (!options.useTildes && typeof options.omitPadding !== B)
+    if (!options.useTildes && typeof options.omitPadding !== 'boolean')
     {
       options.omitPadding = true;
     }
@@ -192,7 +192,7 @@ function encodeText(data, options={})
  */
 function decodeText(base64, options={})
 {
-  if (typeof options === B) 
+  if (typeof options === 'boolean') 
   { // Assume the 'url' option.
     options = {url: options};
   }
@@ -201,7 +201,7 @@ function decodeText(base64, options={})
   { // Unless explicitly disabled, use deurlize() first.
     if (UI8_FB64)
     {
-      if (typeof options.alphabet !== S)
+      if (typeof options.alphabet !== 'string')
       {
         if (URL_CHARS.test(base64))
         {
@@ -339,7 +339,7 @@ async function fromDataUrl(dataUrl, options={})
  */
 async function encodeData(data, options={})
 {
-  let base64 = await toDataUrl(data, options).replace(R_PRE, '');
+  let base64 = (await toDataUrl(data, options)).replace(R_PRE, '');
   return options.url ? urlize(base64, options) : base64;
 }
 
@@ -365,7 +365,7 @@ async function decodeData(base64, options={})
     { // Unless explicitly disabled, use deurlize() first.
       base64 = deurlize(base64);
     }
-    const type = (typeof options.type === S) ? options.type : D_MIME;
+    const type = (typeof options.type === 'string') ? options.type : D_MIME;
     base64 = P_DATA+type+P_B64+base64;
   }
   
@@ -392,7 +392,7 @@ async function decodeData(base64, options={})
  */
 function encode(data, options={})
 {
-  if (options.blob || options.file || (typeof data !== S))
+  if (options.blob || options.file || (typeof data !== 'string'))
   {
     return encodeData(data, options);
   }

package/lib/base91.js

@@ -1,5 +1,3 @@
-const {S,B} = require('@lumjs/core/types');
-
 /**
  * A pure-Javascript base91 library.
  * 
@@ -33,7 +31,7 @@ exports.encode = function(data)
 {
   let output = '';
   let len = data.length,
-    isStr = (typeof data === S),
+    isStr = (typeof data === 'string'),
     queue = 0,
     numbits = 0,
     value = 0;
@@ -131,7 +129,7 @@ exports.decode = function(data, opts={})
 {
   const output = [];
   let len = data.length,
-    isStr = (typeof data === S),
+    isStr = (typeof data === 'string'),
     queue = 0,
     numbits = 0,
     value = -1,
@@ -164,7 +162,7 @@ exports.decode = function(data, opts={})
     output.push(queue | (value << numbits));
   }
 
-  if (typeof opts === B)
+  if (typeof opts === 'boolean')
   {
     opts = {string: opts};
   }

package/lib/hash.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const {S,F,isObj,isNil} = require('@lumjs/core/types');
+const { isObj, isNil } = require('@lumjs/core/types');
 
 const util   = require('./util');
 const base32 = require('./base32');
@@ -130,7 +130,7 @@ module.exports = class
    */
   constructor(options={})
   {
-    if (typeof options === S)
+    if (typeof options === 'string')
     {
       options = {algo: options};
     }
@@ -146,7 +146,7 @@ module.exports = class
     }
 
     this.algo = this.getAlgorithm(
-      (typeof options.algo === S) 
+      (typeof options.algo === 'string') 
       ? options.algo
       : D_ALGO);
 
@@ -243,11 +243,11 @@ module.exports = class
 
       const joiner = this.current.joiner;
 
-      if (typeof joiner === F)
+      if (typeof joiner === 'function')
       {
         input = joiner.call(this, this.current.hash);
       }
-      else if (typeof joiner === S)
+      else if (typeof joiner === 'string')
       {
         input = this.current.hash.join(joiner);
       }
@@ -258,10 +258,10 @@ module.exports = class
       }
 
       // Now clear the current hash values.
-      this.current.hash.length = 0;
+      this.reset();
     }
 
-    if (typeof input === S)
+    if (typeof input === 'string')
     { // This is super simple.
       const encoder = new TextEncoder();
       input = encoder.encode(input);
@@ -377,12 +377,12 @@ module.exports = class
    */
   add(input, opts={})
   {
-    if (typeof input !== S)
+    if (typeof input !== 'string')
     {
       let enc   = this.current.encoder, 
           eopts = null;
 
-      if (typeof enc === S)
+      if (typeof enc === 'string')
       {
         enc = DATA_ENCODERS[enc];
         eopts = this.defaults[enc];
@@ -391,11 +391,11 @@ module.exports = class
       // Compile the options for the encoder.
       eopts = Object.assign({hashifier: this}, eopts, opts);
 
-      if (typeof enc === F)
+      if (typeof enc === 'function')
       { // Call the function, using the hashifier instance as `this`.
         input = enc.call(this, input, eopts);
       }
-      else if (isObj(enc) && typeof enc.encode === F)
+      else if (isObj(enc) && typeof enc.encode === 'function')
       { // Using an encoder object/instance.
         input = enc.encode(input, eopts);
       }
@@ -432,6 +432,11 @@ module.exports = class
     return this;
   }
 
+  reset() {
+    this.current.hash.length = 0;
+    return this;
+  }
+
   static new(opts={})
   {
     return new this(opts);

package/lib/hotp.js

@@ -3,11 +3,17 @@
 const HmacEncoder = require('./hmac');
 const { intToBytes } = require('./util');
 
+const DEBUG = Object.freeze({
+  LOG:  1,
+  INFO: 2,
+});
+
 const DEF_OPTS = { 
   algorithm: 'SHA-1',
   checkSize: 7,
-  counter: 0, 
-  window: 50 
+  counter: 0,
+  debug: 0,
+  window: 50
 };
 
 const cp = Object.assign;
@@ -50,9 +56,11 @@ class HOTP {
     return [DEF_OPTS];
   }
 
-  async generate(key = this.defaultKey, opts) {
-    needKey(key);
-    opts = this.getOptions(opts);
+  async generate(key = this.defaultKey, opts, fromVerify=false) {
+    if (!fromVerify) {
+      needKey(key);
+      opts = this.getOptions(opts);
+    }
 
     let encoder = new HmacEncoder(key, opts);
     let data = new Uint8Array(intToBytes(opts.counter));
@@ -70,20 +78,27 @@ class HOTP {
     let code = Array(opts.checkSize - v2.length).join('0') + v2;
 
     let res = {
-      opts,
-      data,
-      hash,
-      hashBytes: hb,
-      offset,
-      v1,
-      v2,
       code,
+      opts,
       toString() {
         return this.code;
       },
     }
 
-    if (opts.debug) console.debug(res.code, res);
+    if (opts.debug & DEBUG.INFO) {
+      cp(res, {
+        data,
+        hash,
+        hashBytes: hb,
+        offset,
+        v1,
+        v2,
+      });
+    }
+
+    if (!fromVerify && (opts.debug & DEBUG.LOG)) { 
+      console.debug(res.code, res);
+    }
 
     return res;
   }
@@ -95,25 +110,36 @@ class HOTP {
     let win = opts.window;
     let cnt = opts.counter;
     let info = { ok: false };
+    let di = (opts.debug & DEBUG.INFO);
 
-    if (opts.debug) info.stack = [];
+    let done = (add) => {
+      if (add) cp(info, add); // add final info
+      if (opts.debug & DEBUG.LOG) console.debug(info);
+
+      if (!info.ok && opts.throw) {
+        let EClass = isError(opts.throw) ? opts.throw : Error;
+        throw new EClass("OTP verification failure");        
+      }
+
+      return info;
+    }
+
+    if (di) info.stack = [];
 
     for (let i = cnt - win; i <= cnt + win; ++i) {
       opts.counter = i;
-      let res = this.generate(key, opts);
-      if (opts.debug) info.stack.push(res);
+      let res = this.generate(key, opts, true);
+      if (di) info.stack.push(res);
       if (res.code === token) {
-        return cp(info, { ok: true, delta: i - cnt });
+        return done({ ok: true, delta: i - cnt });
       }
     }
 
-    if (opts.throw) {
-      let EClass = isError(opts.throw) ? opts.throw : Error;
-      throw new EClass("OTP verification failure");
-    }
-
-    return info;
+    return done();
   }
 }
 
+HOTP.DEBUG = DEBUG;
+HOTP.prototype.DEBUG = DEBUG;
+
 module.exports = HOTP;

package/lib/index.js

@@ -3,24 +3,22 @@
  * @module @lumjs/encode
  */
 
-const {def,lazy} = require('@lumjs/core/types');
-
-const E = def.e;
-
+const {df,lazy} = require('@lumjs/core');
+const E = {enumerable: true};
 const util = require('./util');
 
 /**
  * @alias module:@lumjs/encode.util
  * @see {@link module:@lumjs/encode/util}
  */
-def(exports, 'util', {value: util}, E);
+df(exports, 'util', {value: util}, E);
 
 /**
  * @alias module:@lumjs/encode.ord
  * @deprecated this alias to `util.ord` will be removed in 3.x.
  * @see {@link module:@lumjs/encode/util.ord}
  */
-def(exports, 'ord', util.ord, E);
+df(exports, 'ord', util.ord, E);
 
 /**
  * @name module:@lumjs/encode.numByteArray
@@ -28,7 +26,7 @@ def(exports, 'ord', util.ord, E);
  * @deprecated this alias to `util.numByteArray` will be removed in 3.x.
  * @see {@link module:@lumjs/encode/util.numByteArray}
  */
-def(exports, 'numByteArray', util.numByteArray, E);
+df(exports, 'numByteArray', util.numByteArray, E);
 
 /**
  * @name module:@lumjs/encode.Base32
@@ -66,6 +64,12 @@ lazy(exports, 'HMAC', () => require('./hmac'), E);
  */
 lazy(exports, 'HOTP', () => require('./hotp'), E);
 
+/**
+ * @name module:@lumjs/encode.PEM
+ * @see {@link module:@lumjs/encode/pem}
+ */
+lazy(exports, 'PEM', () => require('./pem'), E);
+
 /**
  * @name module:@lumjs/encode.TOTP
  * @see {@link module:@lumjs/encode/totp}

package/lib/pem.js

@@ -0,0 +1,128 @@
+'use strict';
+
+const { str2ta } = require('./util');
+
+const UI8_FB64 = (typeof Uint8Array.fromBase64 === 'function');
+const PEM_TEXT = /^\s*-----BEGIN\s+(?<label>[A-Z\s]+)-----\n(?<base64>.*?)\n-----END\s+\k<label>-----\s*$/s;
+const parseText = (str) => (PEM_TEXT.exec(str)?.groups ?? null);
+const validInfo = (pem) => (pem
+  && typeof pem === 'object' 
+  && typeof pem.label === 'string'
+  && typeof pem.base64 === 'string'
+);
+
+/**
+ * A class for parsing and decoding PEM documents.
+ * 
+ * PEM is a format commonly used for encryption keys.
+ * See: https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail
+ * 
+ * @alias {module:@lumjs/encode/pem}
+ */
+class PEM {
+
+  /**
+   * Parse a string into a PEM object instance.
+   * 
+   * This method is strict and will throw an error on failure.
+   * For a more lenient way to parse PEM documents, see the
+   * {@link module:@lumjs/encode/pem.parse parse()} method. 
+   * 
+   * @param {string} pem - PEM format string to be parsed.
+   * @throws {TypeError} If the `pem` argument is an invalid value.
+   * @throws {SyntaxErrror} If the `pem` string was not able to be parsed.
+   */
+  constructor(pem) {
+
+    if (typeof pem === 'string') {
+      let pemStr = pem;
+      pem = parseText(pemStr);
+      if (!validInfo(pem)) {
+        console.error('new PEM()', pemStr);
+        throw new SyntaxError("invalid PEM string passed to PEM constructor");
+      }
+    }
+    else if (!validInfo(pem)) {
+      console.error('new PEM()', pem);
+      throw new TypeError("invalid argument passed to PEM constructor");
+    }
+
+    // Copy the properties from the info into this.
+    Object.assign(this, pem);
+  }
+
+  /**
+   * Decode the base64 content.
+   * 
+   * @param {(boolean|function)} [typeClass=false] Return a TypedArray?
+   * 
+   * This may be set to the constructor function of any TypedArray class.
+   * It may also be set to `true` as an alias for `Uint8Array`.
+   * 
+   * If it is set to `false` (the default), then the binary string output
+   * from the `atob()` global function will be used as the return value.
+   * 
+   * If this is set to Uint8Array (either explicitly or by using `true`),
+   * and a method named `Uint8Array.fromBase64` exists, then this will use
+   * that to parse the base64 content rather than using the
+   * {@link module:@lumjs/encode/util.str2ta str2ta()} function.
+   * 
+   * @returns {(string|TypedArray|Error)}
+   * 
+   * If an error is thrown by any functions being used to decode the base64
+   * content, that error will be the return value.
+   * 
+   * Otherwise the `typeClass` argument will determine the returned type.
+   */
+  decode(typeClass=false) {
+    if (typeClass === true) {
+      typeClass = Uint8Array;
+    }
+
+    let val = null;
+
+    if (UI8_FB64 && typeClass === Uint8Array) { 
+      try {
+        val = typeClass.fromBase64(this.base64);
+      } catch (err) {
+        return err;
+      }
+      return val;
+    }
+
+    try {
+      val = atob(this.base64); 
+    } catch (err) {
+      return err;
+    }
+    
+    if (typeClass && typeof val === 'string') {
+      try {
+        val = str2ta(val, typeClass);
+      } catch (err) {
+        return err;
+      }
+    }
+
+    return val;
+  }
+
+  /**
+   * Parse a string into a PEM object instance.
+   * 
+   * This is almost identical to the main class constructor,
+   * except this version will simply return null if the argument
+   * could not be parsed as a valid PEM string.
+   * 
+   * @param {string} pemText - PEM format string to be parsed.
+   * @returns {?module:@lumjs/encode/pem} A PEM instance;
+   * or null if the pemText could not be parsed.
+   */
+  static parse(pemText) {
+    let info = parseText(pemText);
+    return info ? new this(info) : info;
+  }
+
+}
+
+module.exports = PEM;

package/lib/totp.js

@@ -12,10 +12,16 @@ class TOTP extends HOTP {
     return [...super.defaultOptions, DEF_OPTS];
   }
 
+  getExpiry(opts) {
+    return this.getOptions(opts).expires;
+  }
+
   getOptions() {
     let opts = super.getOptions(...arguments);
     if (!opts.time) opts.time = Date.now();
-    opts.counter = Math.floor((opts.time / 1000) / opts.step);
+    let ts = opts.time / 1000;
+    opts.counter = Math.floor(ts / opts.step);
+    opts.expires = 30 - Math.floor(ts) % 30;
     return opts;
   }
 }

package/lib/util.js

@@ -4,7 +4,7 @@
  */
 'use strict';
 
-const {N} = require('@lumjs/core/types');
+const { TypedArray } = require('@lumjs/core/types');
 
 /**
  * Return the ASCII/Unicode number for a character.
@@ -96,7 +96,7 @@ exports.ord = function (string)
  */
 exports.numByteArray = function (numStr, options={})
 {
-  if (typeof options === N)
+  if (typeof options === 'number')
   {
     options = {size: options};
   }
@@ -104,7 +104,7 @@ exports.numByteArray = function (numStr, options={})
   const numOpt = (name, defval, min, max) => 
   {
     const optval = options[name];
-    if (typeof optval !== N)
+    if (typeof optval !== 'number')
     { // Was not a number, skip it.
       return defval;
     }
@@ -138,7 +138,7 @@ exports.numByteArray = function (numStr, options={})
     remainder = strLen % len;
     if (remainder !== 0)
     { // Something is wrong in the universe...
-      console.debug({numStr, strLen, len, remainder, arguments});
+      console.error({numStr, strLen, len, remainder, arguments});
       throw new Error("string has remainder after padding");
     }
   }
@@ -230,3 +230,43 @@ exports.hexToBytes = function(hex) {
 	return bytes;
 }
 
+/**
+ * Convert a binary string into a TypedArray.
+ * 
+ * Inspired by the str2ab() example from:
+ * https://developer.chrome.com/blog/how-to-convert-arraybuffer-to-and-from-string
+ * 
+ * The biggest difference being this version supports specifying the specific
+ * TypedArray class you want to use, and it returns the TypedArray by default
+ * rather than the ArrayBuffer. 
+ * 
+ * To get the ArrayBuffer just use: `str2ta(string).buffer;` 
+ * 
+ * @param {string} str - Binary string to convert.
+ * @param {function} [typeClass=Uint8Array] TypedArray class to use;
+ * MUST be a TypedArray class constructor. Default is `Uint8Array`.
+ * @returns {TypedArray} Will be an instance of `typeClass`.
+ * @throws {TypeError} If invalid arguments were passed.
+ */
+function str2ta(str, typeClass=Uint8Array) 
+{
+  let valid = {
+    str: (typeof str === 'string'),
+    typeClass: (TypedArray.isPrototypeOf(typeClass)),
+  }
+  if (!valid.str || !valid.typeClass) {
+    console.error('str2ab valid:', valid, 'values: ', {str, typeClass});
+    throw new TypeError("invalid arguments");
+  }
+
+  let buf = new ArrayBuffer(str.length*typeClass.BYTES_PER_ELEMENT);
+  let bufView = new typeClass(buf);
+  for (let i = 0, strLen = str.length; i < strLen; i++) 
+  {
+    bufView[i] = str.charCodeAt(i);
+  }
+
+  return bufView;
+}
+
+exports.str2ta = str2ta;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumjs/encode",
-  "version": "2.3.2",
+  "version": "2.4.1",
   "main": "lib/index.js",
   "exports":
   {
@@ -11,6 +11,7 @@
     "./hash": "./lib/hash.js",
     "./hmac": "./lib/hmac.js",
     "./hotp": "./lib/hotp.js",
+    "./pem": "./lib/pem.js",
     "./signature": "./lib/signature.js",
     "./totp": "./lib/totp.js",
     "./util": "./lib/util.js",