@lumjs/encode 2.4.1 → 2.6.0

package/lib/util.js

@@ -6,6 +6,8 @@
 
 const { TypedArray } = require('@lumjs/core/types');
 
+const UI8_FHEX  = (typeof Uint8Array.fromHex === 'function');
+
 /**
  * Return the ASCII/Unicode number for a character.
  * 
@@ -18,8 +20,7 @@ const { TypedArray } = require('@lumjs/core/types');
  * @param {string} string
  * @returns {number}
  */
-exports.ord = function (string)
-{
+exports.ord = function (string) {
   //  discuss at: https://locutus.io/php/ord/
   // original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
   // bugfixed by: Onno Marsman
@@ -32,12 +33,10 @@ exports.ord = function (string)
 
   var str = string + '',
     code = str.charCodeAt(0);
-  if (0xD800 <= code && code <= 0xDBFF) 
-  {
+  if (0xD800 <= code && code <= 0xDBFF) {
     // High surrogate (could change last hex to 0xDB7F to treat high private surrogates as single characters)
     var hi = code;
-    if (str.length === 1) 
-    {
+    if (str.length === 1) {
       // This is just a high surrogate with no following low surrogate, so we return its value;
       return code;
       // we could also throw an error as it is not a complete character, but someone may want to know
@@ -45,8 +44,7 @@ exports.ord = function (string)
     var low = str.charCodeAt(1);
     return ((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000;
   }
-  if (0xDC00 <= code && code <= 0xDFFF) 
-  {
+  if (0xDC00 <= code && code <= 0xDFFF) {
     // Low surrogate
     // This is just a low surrogate with no preceding high surrogate, so we return its value;
     return code;
@@ -94,67 +92,56 @@ exports.ord = function (string)
  * 
  * @returns {Array} An array of integers.
  */
-exports.numByteArray = function (numStr, options={})
-{
-  if (typeof options === 'number')
-  {
-    options = {size: options};
+exports.numByteArray = function (numStr, options = {}) {
+  if (typeof options === 'number') {
+    options = { size: options };
   }
 
-  const numOpt = (name, defval, min, max) => 
-  {
+  const numOpt = (name, defval, min, max) => {
     const optval = options[name];
-    if (typeof optval !== 'number')
-    { // Was not a number, skip it.
+    if (typeof optval !== 'number') { // Was not a number, skip it.
       return defval;
     }
-    if (optval < min)
-    { // Value was lower than minimum.
+    if (optval < min) { // Value was lower than minimum.
       throw new RangeError(`${name} value ${optval} is less than ${min}`);
     }
-    if (max !== 0 && optval > max)
-    { // Value was higher than maximum.
+    if (max !== 0 && optval > max) { // Value was higher than maximum.
       throw new RangeError(`${name} value ${optval} is more than ${max}`);
     }
 
     return optval;
   }
 
-  const len  = numOpt('size', 2,  1, 0);
+  const len = numOpt('size', 2, 1, 0);
   const base = numOpt('base', 16, 2, 36);
 
   let strLen = numStr.length;
   let remainder = strLen % len;
 
-  if (options.strict && remainder !== 0)
-  {
+  if (options.strict && remainder !== 0) {
     throw new RangeError(`string length ${strLen} is not divisible by ${len}`);
   }
-  else if (options.pad && remainder !== 0)
-  {
+  else if (options.pad && remainder !== 0) {
     const padSize = len - remainder;
-    numStr = numStr.padStart(strLen+padSize, '0');
+    numStr = numStr.padStart(strLen + padSize, '0');
     strLen = numStr.length;
     remainder = strLen % len;
-    if (remainder !== 0)
-    { // Something is wrong in the universe...
-      console.error({numStr, strLen, len, remainder, arguments});
+    if (remainder !== 0) { // Something is wrong in the universe...
+      console.error({ numStr, strLen, len, remainder, arguments });
       throw new Error("string has remainder after padding");
     }
   }
 
-  const endOf = strLen - (len-1);
+  const endOf = strLen - (len - 1);
   const bytes = [];
 
-  const getBytes = (a,b) => bytes.push(parseInt(numStr.substring(a, b), base));
+  const getBytes = (a, b) => bytes.push(parseInt(numStr.substring(a, b), base));
 
-  for(let i=0; i < endOf; i+=len) 
-  {
-    getBytes(i, i+len);
+  for (let i = 0; i < endOf; i += len) {
+    getBytes(i, i + len);
   }
 
-  if (remainder !== 0)
-  {
+  if (remainder !== 0) {
     getBytes(strLen - remainder, strLen);
   }
 
@@ -167,27 +154,26 @@ exports.numByteArray = function (numStr, options={})
  * @param {WordArray} wordArray
  * @returns {Uint8Array}
  */
-exports.wordArrayToUint8Array = function(wordArray) 
-{
-  const l = wordArray.sigBytes;                                                                                                        
-  const words = wordArray.words;                                                                                                       
-  const result = new Uint8Array(l);                                                                                                    
-  var i=0 /*dst*/, j=0 /*src*/;
-  while(true) {
-      // here i is a multiple of 4
-      if (i==l)
-          break;
-      var w = words[j++];
-      result[i++] = (w & 0xff000000) >>> 24;
-      if (i==l)
-          break;
-      result[i++] = (w & 0x00ff0000) >>> 16;                                                                                            
-      if (i==l)                                                                                                                        
-          break;                                                                                                                       
-      result[i++] = (w & 0x0000ff00) >>> 8;
-      if (i==l)
-          break;
-      result[i++] = (w & 0x000000ff);                                                                                                  
+exports.wordArrayToUint8Array = function (wordArray) {
+  const l = wordArray.sigBytes;
+  const words = wordArray.words;
+  const result = new Uint8Array(l);
+  var i = 0 /*dst*/, j = 0 /*src*/;
+  while (true) {
+    // here i is a multiple of 4
+    if (i == l)
+      break;
+    var w = words[j++];
+    result[i++] = (w & 0xff000000) >>> 24;
+    if (i == l)
+      break;
+    result[i++] = (w & 0x00ff0000) >>> 16;
+    if (i == l)
+      break;
+    result[i++] = (w & 0x0000ff00) >>> 8;
+    if (i == l)
+      break;
+    result[i++] = (w & 0x000000ff);
   }
   return result;
 }
@@ -199,35 +185,70 @@ exports.wordArrayToUint8Array = function(wordArray)
  * and was borrowed from the `notp` package.
  *
  * @param {Integer} num
- * @return {Array} bytes
+ * @returns {Array} bytes
  */
-exports.intToBytes = function(num) 
-{
-	let bytes = [];
+exports.intToBytes = function (num) {
+  let bytes = [];
 
-	for(let i=7 ; i>=0 ; --i) 
-  {
-		bytes[i] = num & (255);
-		num = num >> 8;
-	}
+  for (let i = 7; i >= 0; --i) {
+    bytes[i] = num & (255);
+    num = num >> 8;
+  }
 
-	return bytes;
+  return bytes;
 }
 
 /**
- * Convert a hex value to a byte array.
+ * Convert a hex string to a byte array.
  *
- * Also taken from the `notp` package.
+ * Original version was also from the `notp` package,
+ * with some of my own enhancements added.
  *
- * @param {String} hex string of hex to convert to a byte array
- * @return {Array} bytes
+ * @param {string} hex - Hex string to convert to a byte array.
+ * @param {boolean} [uint8=false] Return a Uint8Array?
+ * @param {boolean} [native=true] Use Uint8Array.fromHex() if it exists?
+ * 
+ * Obviously only applicable if `unit8` is true, this will use the native
+ * method if it exists. The only reason I could think of to disable this 
+ * is if you are using this function as a polyfill.
+ * 
+ * @returns {(number[]|Uint8Array)}
+ */
+exports.hexToBytes = function (hex, uint8 = false, native = true) {
+
+  if (uint8 && native && UI8_FHEX) {
+    // A shortcut for modern JS runtimes.
+    return Uint8Array.fromHex(hex);
+  }
+
+  let bytes = [];
+  for (let c = 0, C = hex.length; c < C; c += 2) {
+    bytes.push(parseInt(hex.substring(c, c+2), 16));
+  }
+  return uint8 ? new Uint8Array(bytes) : bytes;
+}
+
+/**
+ * Converts a byte array to a hex string.
+ * 
+ * @param {(Uint8Array|number[])} bytes - Byte array.
+ * @param {boolean} [native=true] Use bytes.toHex() if it exists?
+ * 
+ * Like the same-named option in hexToBytes, the only reason I could
+ * think of to disable this is if you are using this as a polyfill
+ * for the `Uint8Array.prototype.toHex` method.
+ * 
+ * @returns {string}
  */
-exports.hexToBytes = function(hex) {
-	var bytes = [];
-	for(var c = 0, C = hex.length; c < C; c += 2) {
-		bytes.push(parseInt(hex.substr(c, 2), 16));
-	}
-	return bytes;
+exports.bytesToHex = function (bytes, native = true) {
+  
+  if (native && typeof bytes.toHex === 'function') {
+    return bytes.toHex();
+  }
+
+  return Array.from(bytes, function (byte) {
+    return ('0' + (byte & 0xFF).toString(16)).slice(-2);
+  }).join('');
 }
 
 /**
@@ -248,21 +269,19 @@ exports.hexToBytes = function(hex) {
  * @returns {TypedArray} Will be an instance of `typeClass`.
  * @throws {TypeError} If invalid arguments were passed.
  */
-function str2ta(str, typeClass=Uint8Array) 
-{
+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});
+    console.error('str2ab valid:', valid, 'values: ', { str, typeClass });
     throw new TypeError("invalid arguments");
   }
 
-  let buf = new ArrayBuffer(str.length*typeClass.BYTES_PER_ELEMENT);
+  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++) 
-  {
+  for (let i = 0, strLen = str.length; i < strLen; i++) {
     bufView[i] = str.charCodeAt(i);
   }
 

package/lum.build.js

@@ -0,0 +1,24 @@
+module.exports = function(rb)
+{
+  rb.project
+  .add('index')
+  .types('./types/auto')
+  .add('base32')
+  .add('base64')
+  .add('base91')
+  .add('hash')
+  .add('hmac')
+  .add('hotp')
+  .add('polyfill')
+  .add('signature')
+  .add('totp')
+  .add('util')
+  .src('./lib/sets')
+  .types('./types/sets')
+  .add('all')
+  .add('base')
+  .add('digest')
+  .add('otp')
+  .add('sign')
+  .save();
+}

package/package.json

@@ -1,39 +1,88 @@
 {
   "name": "@lumjs/encode",
-  "version": "2.4.1",
+  "version": "2.6.0",
   "main": "lib/index.js",
-  "exports":
-  {
+  "exports": {
     ".": "./lib/index.js",
-    "./base32": "./lib/base32.js",
-    "./base64": "./lib/base64.js",
-    "./base91": "./lib/base91.js",
-    "./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",
+    "./base32": {
+      "types": "./types/auto/base32.d.ts",
+      "default": "./lib/base32.js"
+    },
+    "./base64": {
+      "types": "./types/auto/base64.d.ts",
+      "default": "./lib/base64.js"
+    },
+    "./base91": {
+      "types": "./types/auto/base91.d.ts",
+      "default": "./lib/base91.js"
+    },
+    "./hash": {
+      "types": "./types/auto/hash.d.ts",
+      "default": "./lib/hash.js"
+    },
+    "./hmac": {
+      "types": "./types/auto/hmac.d.ts",
+      "default": "./lib/hmac.js"
+    },
+    "./hotp": {
+      "types": "./types/auto/hotp.d.ts",
+      "default": "./lib/hotp.js"
+    },
+    "./polyfill": {
+      "types": "./types/auto/polyfill.d.ts",
+      "default": "./lib/polyfill.js"
+    },
+    "./signature": {
+      "types": "./types/auto/signature.d.ts",
+      "default": "./lib/signature.js"
+    },
+    "./totp": {
+      "types": "./types/auto/totp.d.ts",
+      "default": "./lib/totp.js"
+    },
+    "./util": {
+      "types": "./types/auto/util.d.ts",
+      "default": "./lib/util.js"
+    },
+    "./all": {
+      "types": "./types/sets/all.d.ts",
+      "default": "./lib/sets/all.js"
+    },
+    "./base": {
+      "types": "./types/sets/base.d.ts",
+      "default": "./lib/sets/base.js"
+    },
+    "./digest": {
+      "types": "./types/sets/digest.d.ts",
+      "default": "./lib/sets/digest.js"
+    },
+    "./otp": {
+      "types": "./types/sets/otp.d.ts",
+      "default": "./lib/sets/otp.js"
+    },
+    "./sign": {
+      "types": "./types/sets/sign.d.ts",
+      "default": "./lib/sets/sign.js"
+    },
     "./package.json": "./package.json"
   },
   "license": "MIT",
-  "repository":
-  {
+  "repository": {
     "type": "git",
     "url": "https://github.com/supernovus/lum.encode.js.git"
   },
-  "dependencies": 
-  {
+  "dependencies": {
     "@lumjs/core": "^1.28.0"
   },
-  "devDependencies":
-  {
+  "devDependencies": {
+    "@lumjs/build": "^1.2.0",
     "@lumjs/tests": "^2.0.0"
   },
-  "scripts":
-  {
-    "test": "node ./node_modules/@lumjs/tests/bin/lumtest.js",
-    "build-docs": "jsdoc -c ./jsdoc.json"
+  "scripts": {
+    "build": "npm run build-types && npm run build-meta && npm run build-docs",
+    "build-docs": "jsdoc -c ./jsdoc.js",
+    "build-meta": "lum-build",
+    "build-types": "npx -p typescript tsc",
+    "test": "node ./node_modules/@lumjs/tests/bin/lumtest.js"
   }
-}
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  // I would use ["lib/**/*"] except I have no idea how to get typescript
+  // to recognise 'sets' aliases, so I'm building those .d.ts files by hand.
+  "include": ["lib/*.js"],
+  "compilerOptions": {
+    "allowJs": true,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "outDir": "types/auto",
+    "declarationMap": true
+  }
+}

package/types/auto/base32.d.ts

@@ -0,0 +1,72 @@
+export namespace Base32Types {
+    export default Base32Types.rfc4648;
+}
+/**
+ * Encode a value into a Base32 string.
+ *
+ * @param {(ArrayBuffer|TypedArray|string)} data - Data to be encoded.
+ *
+ * If this is a string it will be converted into a Uint8Array using a
+ * TextEncoder instance.
+ *
+ * @param {(object|string|boolean)} [opts] Options.
+ *
+ * If this is a boolean it will be used as `opts.pad`.
+ *
+ * If this is a string or one of the `Base32Types` properties,
+ * it will be used as `opts.type`.
+ *
+ * @param {(string|Array)} [opts.type] Base32 variant to use.
+ *
+ * If this is a string it must be the name (uppercase or lowercase)
+ * of one of the properties in the `Base32Types` object.
+ *
+ * If it is an Array it is expected that it is one of the properties
+ * from the Base32Types, or a compatible type def where the first
+ * item in the array is a string consisting of exactly 32 unique characters.
+ *
+ * @param {boolean} [opts.pad=true] Add `=` padding characters?
+ *
+ * Base32 (like Base64) uses `=` as a padding character to ensure the length
+ * of the encoded strings are divisible by 8. As that is a part of
+ * the standard specification, this option defaults to true.
+ *
+ * If you explicitly set this to false the string won't have any padding
+ * added to it, regardless of its length.
+ *
+ * @returns {string}
+ * @alias module:@lumjs/encode/base32.encode
+ */
+export function base32Encode(buf: any, opts?: (object | string | boolean)): string;
+/**
+ * Decode a Base32-encoded string.
+ * @param {string} str - Base32 string.
+ * @param {(object|string)} [opts] Options.
+ *
+ * If this is a boolean it will be used as `opts.string`.
+ *
+ * If this is a string or one of the `Base32Types` properties,
+ * it will be used as `opts.type`.
+ *
+ * @param {(string|Array)} [opts.type] Base32 variant to use.
+ *
+ * If this is a string it must be the name (uppercase or lowercase)
+ * of one of the properties in the `Base32Types` object.
+ *
+ * If it is an Array it is expected that it is one of the properties
+ * from the Base32Types, or a compatible type def where the first
+ * item in the array is a string consisting of exactly 32 unique characters.
+ *
+ * @param {boolean} [opts.string=false] Return a UTF-8 string?
+ *
+ * If this is true then we will assume the original encoded value was a UTF-8
+ * string, and will decode it as such using a TextDecoder instance.
+ *
+ * If this is false (the default) we will return a Uint8Array.
+ *
+ * @returns {(Uint8Array|string)}
+ * @alias module:@lumjs/encode/base32.decode
+ */
+export function base32Decode(str: string, opts?: (object | string)): (Uint8Array | string);
+export { Base32Types as TYPES, base32Encode as encode, base32Decode as decode };
+//# sourceMappingURL=base32.d.ts.map

package/types/auto/base32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base32.d.ts","sourceRoot":"","sources":["../../lib/base32.js"],"names":[],"mappings":";;;AA0JA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,8CA5BW,CAAC,MAAM,GAAC,MAAM,GAAC,OAAO,CAAC,GAyBrB,MAAM,CAiClB;AAvHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,kCA3BW,MAAM,SACN,CAAC,MAAM,GAAC,MAAM,CAAC,GAuBb,CAAC,UAAU,GAAC,MAAM,CAAC,CAyB/B"}