charSet.js

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var BITS_PER_BYTE = 8;
var abs = Math.abs,
    ceil = Math.ceil,
    floor = Math.floor,
    log2 = Math.log2;

var gcd = function gcd(a, b) {
  var la = a;
  var lb = b;

  while (lb !== 0) {
    var _ref = [lb, la % lb];
    la = _ref[0];
    lb = _ref[1];
  }

  return abs(la);
};

var lcm = function lcm(a, b) {
  return a / gcd(a, b) * b;
};

var genNdxFn = function genNdxFn(bitsPerChar) {
  // If BITS_PER_BYTEs is a multiple of bitsPerChar, we can slice off an integer number
  // of chars per byte.
  if (lcm(bitsPerChar, BITS_PER_BYTE) === BITS_PER_BYTE) {
    return function (chunk, slice, bytes) {
      var lShift = bitsPerChar;
      var rShift = BITS_PER_BYTE - bitsPerChar;
      return (bytes[chunk] << lShift * slice & 0xff) >> rShift;
    };
  } // Otherwise, while slicing off bits per char, we can possibly straddle two
  // of bytes, so a more work is involved


  var slicesPerChunk = lcm(bitsPerChar, BITS_PER_BYTE) / BITS_PER_BYTE;
  return function (chunk, slice, bytes) {
    var bNum = chunk * slicesPerChunk;
    var offset = slice * bitsPerChar / BITS_PER_BYTE;
    var lOffset = floor(offset);
    var rOffset = ceil(offset);
    var rShift = BITS_PER_BYTE - bitsPerChar;
    var lShift = slice * bitsPerChar % BITS_PER_BYTE;
    var ndx = (bytes[bNum + lOffset] << lShift & 0xff) >> rShift;
    var r1Bits = (rOffset + 1) * BITS_PER_BYTE;
    var s1Bits = (slice + 1) * bitsPerChar;
    var rShiftIt = (r1Bits - s1Bits) % BITS_PER_BYTE;

    if (rShift < rShiftIt) {
      ndx += bytes[bNum + rOffset] >> rShiftIt;
    }

    return ndx;
  };
};

var CharSet = /*#__PURE__*/function () {
  function CharSet(chars) {
    (0, _classCallCheck2["default"])(this, CharSet);

    if (!(typeof chars === 'string' || chars instanceof String)) {
      throw new Error('Invalid chars: Must be string');
    }

    var length = chars.length;

    if (![2, 4, 8, 16, 32, 64].includes(length)) {
      throw new Error('Invalid char count: must be one of 2,4,8,16,32,64');
    } // Ensure no repeated characters


    for (var i = 0; i < length; i += 1) {
      var c = chars.charAt(i);

      for (var j = i + 1; j < length; j += 1) {
        if (c === chars.charAt(j)) {
          throw new Error('Characters not unique');
        }
      }
    }

    this.chars = chars;
    this.bitsPerChar = floor(log2(length));
    this.length = length;
    this.ndxFn = genNdxFn(this.bitsPerChar);
    this.charsPerChunk = lcm(this.bitsPerChar, BITS_PER_BYTE) / this.bitsPerChar;
  }

  (0, _createClass2["default"])(CharSet, [{
    key: "bytesNeeded",
    value: function bytesNeeded(bitLen) {
      var count = ceil(bitLen / this.bitsPerChar);
      return ceil(count * this.bitsPerChar / BITS_PER_BYTE);
    }
  }]);
  return CharSet;
}();

module.exports = {
  CharSet: CharSet
};