7z-iterator 0.1.6 → 0.1.7

package/assets/lzma-purejs/LICENSE

@@ -0,0 +1,11 @@
+BSD License
+
+lzma-purejs - Pure JavaScript LZMA de/compression
+https://github.com/cscott/lzma-purejs
+
+Copyright (c) Gary Linscott, Juan Mellado, C. Scott Ananian
+
+This vendored copy includes modifications to support LZMA2 solid mode
+(setSolid method for state preservation across chunks).
+
+Original package: https://www.npmjs.com/package/lzma-purejs

package/assets/lzma-purejs/index.js

@@ -0,0 +1,19 @@
+'use strict';
+var LZ = require('./lib/LZ');
+var LZMA = require('./lib/LZMA');
+var RangeCoder = require('./lib/RangeCoder');
+var Stream = require('./lib/Stream');
+var Util = require('./lib/Util');
+
+module.exports = {
+  version: "0.9.0",
+  LZ: LZ,
+  LZMA: LZMA,
+  RangeCoder: RangeCoder,
+  Stream: Stream,
+  Util: Util,
+  compress: Util.compress,
+  compressFile: Util.compressFile,
+  decompress: Util.decompress,
+  decompressFile: Util.decompressFile
+};

package/assets/lzma-purejs/lib/LZ/OutWindow.js

@@ -0,0 +1,78 @@
+'use strict';
+var makeBuffer = require('../makeBuffer');
+
+var OutWindow = function(){
+  this._windowSize = 0;
+};
+
+OutWindow.prototype.create = function(windowSize){
+  if ((!this._buffer) || (this._windowSize !== windowSize)){
+    this._buffer = makeBuffer(windowSize);
+  }
+  this._windowSize = windowSize;
+  this._pos = 0;
+  this._streamPos = 0;
+};
+
+OutWindow.prototype.flush = function(){
+  var size = this._pos - this._streamPos;
+  if (size !== 0){
+    while(size--){
+      this._stream.writeByte(this._buffer[this._streamPos++]);
+    }
+    if (this._pos >= this._windowSize){
+      this._pos = 0;
+    }
+    this._streamPos = this._pos;
+  }
+};
+
+OutWindow.prototype.releaseStream = function(){
+  this.flush();
+  this._stream = null;
+};
+
+OutWindow.prototype.setStream = function(stream){
+  this.releaseStream();
+  this._stream = stream;
+};
+
+OutWindow.prototype.init = function(solid){
+  if (!solid){
+    this._streamPos = 0;
+    this._pos = 0;
+  }
+};
+
+OutWindow.prototype.copyBlock = function(distance, len){
+  var pos = this._pos - distance - 1;
+  if (pos < 0){
+    pos += this._windowSize;
+  }
+  while(len--){
+    if (pos >= this._windowSize){
+      pos = 0;
+    }
+    this._buffer[this._pos++] = this._buffer[pos++];
+    if (this._pos >= this._windowSize){
+      this.flush();
+    }
+  }
+};
+
+OutWindow.prototype.putByte = function(b){
+  this._buffer[this._pos++] = b;
+  if (this._pos >= this._windowSize){
+    this.flush();
+  }
+};
+
+OutWindow.prototype.getByte = function(distance){
+  var pos = this._pos - distance - 1;
+  if (pos < 0){
+    pos += this._windowSize;
+  }
+  return this._buffer[pos];
+};
+
+module.exports = OutWindow;

package/assets/lzma-purejs/lib/LZ.js

@@ -0,0 +1,6 @@
+'use strict';
+var OutWindow = require('./LZ/OutWindow');
+
+module.exports = {
+  OutWindow: OutWindow
+};

package/assets/lzma-purejs/lib/LZMA/Base.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var Base = {};
+Base.kNumRepDistances = 4;
+Base.kNumStates = 12;
+
+Base.stateInit = function() { return 0; };
+Base.stateUpdateChar = function(index) {
+  if (index < 4) return 0;
+  if (index < 10) return index - 3;
+  return index - 6;
+};
+Base.stateUpdateMatch = function(index) { return (index < 7 ? 7 : 10); };
+Base.stateUpdateRep = function(index) { return (index < 7 ? 8 : 11); };
+Base.stateUpdateShortRep = function(index) { return (index < 7 ? 9 : 11); };
+Base.stateIsCharState = function(index) { return index < 7; };
+
+Base.kNumPosSlotBits = 6;
+Base.kDicLogSizeMin = 0;
+Base.kNumLenToPosStatesBits = 2;
+Base.kNumLenToPosStates = 1 << Base.kNumLenToPosStatesBits;
+Base.kMatchMinLen = 2;
+Base.getLenToPosState = function(len) {
+  len -= Base.kMatchMinLen;
+  return len < Base.kNumLenToPosStates ? len : (Base.kNumLenToPosStates - 1);
+};
+Base.kNumAlignBits = 4;
+Base.kAlignTableSize = 1 << Base.kNumAlignBits;
+Base.kAlignMask = (Base.kAlignTableSize - 1);
+Base.kStartPosModelIndex = 4;
+Base.kEndPosModelIndex = 14;
+Base.kNumPosModels = Base.kEndPosModelIndex - Base.kStartPosModelIndex;
+Base.kNumFullDistances = 1 << (Base.kEndPosModelIndex / 2);
+Base.kNumLitPosStatesBitsEncodingMax = 4;
+Base.kNumLitContextBitsMax = 8;
+Base.kNumPosStatesBitsMax = 4;
+Base.kNumPosStatesMax = (1 << Base.kNumPosStatesBitsMax);
+Base.kNumPosStatesBitsEncodingMax = 4;
+Base.kNumPosStatesEncodingMax = (1 << Base.kNumPosStatesBitsEncodingMax);
+Base.kNumLowLenBits = 3;
+Base.kNumMidLenBits = 3;
+Base.kNumHighLenBits = 8;
+Base.kNumLowLenSymbols = 1 << Base.kNumLowLenBits;
+Base.kNumMidLenSymbols = 1 << Base.kNumMidLenBits;
+Base.kNumLenSymbols = Base.kNumLowLenSymbols + Base.kNumMidLenSymbols + (1 << Base.kNumHighLenBits);
+Base.kMatchMaxLen = Base.kMatchMinLen + Base.kNumLenSymbols - 1;
+
+module.exports = Base;

package/assets/lzma-purejs/lib/LZMA/Decoder.js

@@ -0,0 +1,296 @@
+'use strict';
+var Base = require('./Base');
+var LZ = require('../LZ');
+var RangeCoder = require('../RangeCoder');
+
+var initBitModels = RangeCoder.Encoder.initBitModels;
+
+var LenDecoder = function(){
+  this._choice = initBitModels(null, 2);
+  this._lowCoder = [];
+  this._midCoder = [];
+  this._highCoder = new RangeCoder.BitTreeDecoder(8);
+  this._numPosStates = 0;
+};
+
+LenDecoder.prototype.create = function(numPosStates){
+  for (; this._numPosStates < numPosStates; ++this._numPosStates){
+    this._lowCoder[this._numPosStates] = new RangeCoder.BitTreeDecoder(3);
+    this._midCoder[this._numPosStates] = new RangeCoder.BitTreeDecoder(3);
+  }
+};
+
+LenDecoder.prototype.init = function(){
+  initBitModels(this._choice);
+  for (var i = this._numPosStates - 1; i >= 0; i--){
+    this._lowCoder[i].init();
+    this._midCoder[i].init();
+  }
+  this._highCoder.init();
+};
+
+LenDecoder.prototype.decode = function(rangeDecoder, posState){
+  if (rangeDecoder.decodeBit(this._choice, 0) === 0){
+    return this._lowCoder[posState].decode(rangeDecoder);
+  }
+  if (rangeDecoder.decodeBit(this._choice, 1) === 0){
+    return 8 + this._midCoder[posState].decode(rangeDecoder);
+  }
+  return 16 + this._highCoder.decode(rangeDecoder);
+};
+
+var LiteralDecoder = function(){};
+
+LiteralDecoder.Decoder2 = function(){
+  this._decoders = initBitModels(null, 0x300);
+};
+
+LiteralDecoder.Decoder2.prototype.init = function(){
+  initBitModels(this._decoders);
+};
+
+LiteralDecoder.Decoder2.prototype.decodeNormal = function(rangeDecoder){
+  var symbol = 1;
+  do {
+    symbol = (symbol << 1) | rangeDecoder.decodeBit(this._decoders, symbol);
+  } while(symbol < 0x100);
+  return symbol & 0xff;
+};
+
+LiteralDecoder.Decoder2.prototype.decodeWithMatchByte = function(rangeDecoder, matchByte){
+  var symbol = 1;
+  do {
+    var matchBit = (matchByte >> 7) & 1;
+    matchByte <<= 1;
+    var bit = rangeDecoder.decodeBit(this._decoders, ((1 + matchBit) << 8) + symbol);
+    symbol = (symbol << 1) | bit;
+    if (matchBit !== bit){
+      while(symbol < 0x100){
+        symbol = (symbol << 1) | rangeDecoder.decodeBit(this._decoders, symbol);
+      }
+      break;
+    }
+  } while(symbol < 0x100);
+  return symbol & 0xff;
+};
+
+LiteralDecoder.prototype.create = function(numPosBits, numPrevBits){
+  if (this._coders && this._numPrevBits === numPrevBits && this._numPosBits === numPosBits) return;
+  this._numPosBits = numPosBits;
+  this._posMask = (1 << numPosBits) - 1;
+  this._numPrevBits = numPrevBits;
+  this._coders = [];
+  var count = 1 << (this._numPrevBits + this._numPosBits);
+  for (var i = 0; i < count; i++){
+    this._coders[i] = new LiteralDecoder.Decoder2();
+  }
+};
+
+LiteralDecoder.prototype.init = function(){
+  var count = 1 << (this._numPrevBits + this._numPosBits);
+  for (var i = 0; i < count; i++){
+    this._coders[i].init();
+  }
+};
+
+LiteralDecoder.prototype.getDecoder = function(pos, prevByte){
+  return this._coders[((pos & this._posMask) << this._numPrevBits) +
+                      ((prevByte & 0xff) >>> (8 - this._numPrevBits))];
+};
+
+var Decoder = function(){
+  this._outWindow = new LZ.OutWindow();
+  this._rangeDecoder = new RangeCoder.Decoder();
+  this._isMatchDecoders = initBitModels(null, Base.kNumStates << Base.kNumPosStatesBitsMax);
+  this._isRepDecoders = initBitModels(null, Base.kNumStates);
+  this._isRepG0Decoders = initBitModels(null, Base.kNumStates);
+  this._isRepG1Decoders = initBitModels(null, Base.kNumStates);
+  this._isRepG2Decoders = initBitModels(null, Base.kNumStates);
+  this._isRep0LongDecoders = initBitModels(null, Base.kNumStates << Base.kNumPosStatesBitsMax);
+  this._posSlotDecoder = [];
+  this._posDecoders = initBitModels(null, Base.kNumFullDistances - Base.kEndPosModelIndex);
+  this._posAlignDecoder = new RangeCoder.BitTreeDecoder(Base.kNumAlignBits);
+  this._lenDecoder = new LenDecoder();
+  this._repLenDecoder = new LenDecoder();
+  this._literalDecoder = new LiteralDecoder();
+  this._dictionarySize = -1;
+  this._dictionarySizeCheck = -1;
+  this._posStateMask = 0;
+
+  // LZMA2 state preservation
+  this._state = 0;
+  this._rep0 = 0;
+  this._rep1 = 0;
+  this._rep2 = 0;
+  this._rep3 = 0;
+  this._prevByte = 0;
+  this._nowPos64 = 0;
+  this._solid = false;
+
+  for (var i = 0; i < Base.kNumLenToPosStates; i++){
+    this._posSlotDecoder[i] = new RangeCoder.BitTreeDecoder(Base.kNumPosSlotBits);
+  }
+};
+
+Decoder.prototype.setSolid = function(solid) {
+  this._solid = solid;
+};
+
+Decoder.prototype.setDictionarySize = function(dictionarySize){
+  if (dictionarySize < 0) return false;
+  if (this._dictionarySize !== dictionarySize){
+    this._dictionarySize = dictionarySize;
+    this._dictionarySizeCheck = Math.max(this._dictionarySize, 1);
+    this._outWindow.create(Math.max(this._dictionarySizeCheck, (1 << 12)));
+  }
+  return true;
+};
+
+Decoder.prototype.setLcLpPb = function(lc, lp, pb){
+  if (lc > Base.kNumLitContextBitsMax || lp > 4 || pb > Base.kNumPosStatesBitsMax) return false;
+  var numPosStates = 1 << pb;
+  this._literalDecoder.create(lp, lc);
+  this._lenDecoder.create(numPosStates);
+  this._repLenDecoder.create(numPosStates);
+  this._posStateMask = numPosStates - 1;
+  return true;
+};
+
+Decoder.prototype.init = function(){
+  this._outWindow.init(false);
+  initBitModels(this._isMatchDecoders);
+  initBitModels(this._isRepDecoders);
+  initBitModels(this._isRepG0Decoders);
+  initBitModels(this._isRepG1Decoders);
+  initBitModels(this._isRepG2Decoders);
+  initBitModels(this._isRep0LongDecoders);
+  initBitModels(this._posDecoders);
+  this._literalDecoder.init();
+  for (var i = Base.kNumLenToPosStates - 1; i >= 0; i--){
+    this._posSlotDecoder[i].init();
+  }
+  this._lenDecoder.init();
+  this._repLenDecoder.init();
+  this._posAlignDecoder.init();
+  this._rangeDecoder.init();
+};
+
+Decoder.prototype.code = function(inStream, outStream, outSize){
+  var chunkPos = 0, posState, decoder2, len, distance, posSlot, numDirectBits;
+  this._rangeDecoder.setStream(inStream);
+  this._outWindow.setStream(outStream);
+
+  if (!this._solid) {
+    this.init();
+    this._state = Base.stateInit();
+    this._rep0 = 0;
+    this._rep1 = 0;
+    this._rep2 = 0;
+    this._rep3 = 0;
+    this._prevByte = 0;
+    this._nowPos64 = 0;
+  } else {
+    this._outWindow.init(true);
+    this._rangeDecoder.init();
+  }
+  var cumPos = this._nowPos64;
+
+  while(outSize < 0 || chunkPos < outSize){
+    posState = cumPos & this._posStateMask;
+    if (this._rangeDecoder.decodeBit(this._isMatchDecoders, (this._state << Base.kNumPosStatesBitsMax) + posState) === 0){
+      decoder2 = this._literalDecoder.getDecoder(cumPos, this._prevByte);
+      if (!Base.stateIsCharState(this._state)){
+        this._prevByte = decoder2.decodeWithMatchByte(this._rangeDecoder, this._outWindow.getByte(this._rep0));
+      } else {
+        this._prevByte = decoder2.decodeNormal(this._rangeDecoder);
+      }
+      this._outWindow.putByte(this._prevByte);
+      this._state = Base.stateUpdateChar(this._state);
+      chunkPos++; cumPos++;
+    } else {
+      if (this._rangeDecoder.decodeBit(this._isRepDecoders, this._state) === 1){
+        len = 0;
+        if (this._rangeDecoder.decodeBit(this._isRepG0Decoders, this._state) === 0){
+          if (this._rangeDecoder.decodeBit(this._isRep0LongDecoders, (this._state << Base.kNumPosStatesBitsMax) + posState) === 0){
+            this._state = Base.stateUpdateShortRep(this._state);
+            len = 1;
+          }
+        } else {
+          if (this._rangeDecoder.decodeBit(this._isRepG1Decoders, this._state) === 0){
+            distance = this._rep1;
+          } else {
+            if (this._rangeDecoder.decodeBit(this._isRepG2Decoders, this._state) === 0){
+              distance = this._rep2;
+            } else {
+              distance = this._rep3;
+              this._rep3 = this._rep2;
+            }
+            this._rep2 = this._rep1;
+          }
+          this._rep1 = this._rep0;
+          this._rep0 = distance;
+        }
+        if (len === 0){
+          len = Base.kMatchMinLen + this._repLenDecoder.decode(this._rangeDecoder, posState);
+          this._state = Base.stateUpdateRep(this._state);
+        }
+      } else {
+        this._rep3 = this._rep2;
+        this._rep2 = this._rep1;
+        this._rep1 = this._rep0;
+        len = Base.kMatchMinLen + this._lenDecoder.decode(this._rangeDecoder, posState);
+        this._state = Base.stateUpdateMatch(this._state);
+        posSlot = this._posSlotDecoder[Base.getLenToPosState(len)].decode(this._rangeDecoder);
+        if (posSlot >= Base.kStartPosModelIndex){
+          numDirectBits = (posSlot >> 1) - 1;
+          this._rep0 = (2 | (posSlot & 1)) << numDirectBits;
+          if (posSlot < Base.kEndPosModelIndex){
+            this._rep0 += RangeCoder.BitTreeDecoder.reverseDecode(this._posDecoders,
+                this._rep0 - posSlot - 1, this._rangeDecoder, numDirectBits);
+          } else {
+            this._rep0 += this._rangeDecoder.decodeDirectBits(numDirectBits - Base.kNumAlignBits) << Base.kNumAlignBits;
+            this._rep0 += this._posAlignDecoder.reverseDecode(this._rangeDecoder);
+            if (this._rep0 < 0){
+              if (this._rep0 === -1) break;
+              return false;
+            }
+          }
+        } else {
+          this._rep0 = posSlot;
+        }
+      }
+      if (this._rep0 >= cumPos || this._rep0 >= this._dictionarySizeCheck) return false;
+      this._outWindow.copyBlock(this._rep0, len);
+      chunkPos += len; cumPos += len;
+      this._prevByte = this._outWindow.getByte(0);
+    }
+  }
+  this._nowPos64 = cumPos;
+  this._outWindow.flush();
+  this._outWindow.releaseStream();
+  this._rangeDecoder.releaseStream();
+  return true;
+};
+
+Decoder.prototype.setDecoderProperties = function(properties){
+  if (properties.length < 5) return false;
+  var value = properties[0] & 0xFF;
+  var lc = value % 9;
+  value = ~~(value / 9);
+  var lp = value % 5;
+  var pb = ~~(value / 5);
+  if (!this.setLcLpPb(lc, lp, pb)) return false;
+  var dictionarySize = 0;
+  for (var i = 0, shift = 1; i < 4; i++, shift *= 256){
+    dictionarySize += (properties[1+i] & 0xFF) * shift;
+  }
+  return this.setDictionarySize(dictionarySize);
+};
+
+Decoder.prototype.setDecoderPropertiesFromStream = function(stream) {
+  var buffer = [];
+  for (var i = 0; i < 5; i++) { buffer[i] = stream.readByte(); }
+  return this.setDecoderProperties(buffer);
+};
+
+module.exports = Decoder;

package/assets/lzma-purejs/lib/LZMA.js

@@ -0,0 +1,6 @@
+'use strict';
+var Decoder = require('./LZMA/Decoder');
+
+module.exports = {
+  Decoder: Decoder
+};

package/assets/lzma-purejs/lib/RangeCoder/BitTreeDecoder.js

@@ -0,0 +1,41 @@
+'use strict';
+var Encoder = require('./Encoder');
+
+var BitTreeDecoder = function(numBitLevels){
+  this._numBitLevels = numBitLevels;
+  this.init();
+};
+
+BitTreeDecoder.prototype.init = function(){
+  this._models = Encoder.initBitModels(null, 1 << this._numBitLevels);
+};
+
+BitTreeDecoder.prototype.decode = function(rangeDecoder){
+  var m = 1;
+  for (var i = this._numBitLevels; i > 0; i--){
+    m = (m << 1) | rangeDecoder.decodeBit(this._models, m);
+  }
+  return m - (1 << this._numBitLevels);
+};
+
+BitTreeDecoder.prototype.reverseDecode = function(rangeDecoder){
+  var m = 1, symbol = 0;
+  for (var i = 0; i < this._numBitLevels; i++){
+    var bit = rangeDecoder.decodeBit(this._models, m);
+    m = (m << 1) | bit;
+    symbol |= (bit << i);
+  }
+  return symbol;
+};
+
+BitTreeDecoder.reverseDecode = function(models, startIndex, rangeDecoder, numBitLevels) {
+  var m = 1, symbol = 0;
+  for (var i = 0; i < numBitLevels; i++){
+    var bit = rangeDecoder.decodeBit(models, startIndex + m);
+    m = (m << 1) | bit;
+    symbol |= (bit << i);
+  }
+  return symbol;
+};
+
+module.exports = BitTreeDecoder;

package/assets/lzma-purejs/lib/RangeCoder/Decoder.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var Decoder = function(stream){
+  if (stream) {
+    this.setStream(stream);
+    this.init();
+  }
+};
+
+Decoder.prototype.setStream = function(stream){ this._stream = stream; };
+Decoder.prototype.releaseStream = function(){ this._stream = null; };
+
+Decoder.prototype.init = function(){
+  this._code = 0;
+  this._range = -1;
+  for (var i = 0; i < 5; i++){
+    this._code = (this._code << 8) | this._stream.readByte();
+  }
+};
+
+Decoder.prototype.decodeDirectBits = function(numTotalBits){
+  var result = 0;
+  for (var i = numTotalBits; i > 0; i--){
+    this._range >>>= 1;
+    var t = (this._code - this._range) >>> 31;
+    this._code -= this._range & (t - 1);
+    result = (result << 1) | (1 - t);
+    if ((this._range & 0xff000000) === 0){
+      this._code = (this._code << 8) | this._stream.readByte();
+      this._range <<= 8;
+    }
+  }
+  return result;
+};
+
+Decoder.prototype.decodeBit = function(probs, index){
+  var prob = probs[index];
+  var newBound = (this._range >>> 11) * prob;
+  if ((this._code ^ 0x80000000) < (newBound ^ 0x80000000)){
+    this._range = newBound;
+    probs[index] += (2048 - prob) >>> 5;
+    if ((this._range & 0xff000000) === 0){
+      this._code = (this._code << 8) | this._stream.readByte();
+      this._range <<= 8;
+    }
+    return 0;
+  }
+  this._range -= newBound;
+  this._code -= newBound;
+  probs[index] -= prob >>> 5;
+  if ((this._range & 0xff000000) === 0){
+    this._code = (this._code << 8) | this._stream.readByte();
+    this._range <<= 8;
+  }
+  return 1;
+};
+
+module.exports = Decoder;

package/assets/lzma-purejs/lib/RangeCoder/Encoder.js

@@ -0,0 +1,106 @@
+'use strict';
+
+var MAX32 = 0xFFFFFFFF;
+var MAX24 = 0x00FFFFFF;
+var MAX8  = 0x000000FF;
+var MASK24= 0xFF000000;
+
+var kNumBitModelTotalBits = 11;
+var kBitModelTotal = (1 << kNumBitModelTotalBits);
+var kNumMoveBits = 5;
+var kNumMoveReducingBits = 2;
+var kNumBitPriceShiftBits = 6;
+
+var Encoder = function(stream){
+  this.init();
+  if (stream) { this.setStream(stream); }
+};
+Encoder.prototype.setStream = function(stream) { this._stream = stream; };
+Encoder.prototype.releaseStream = function() { this._stream = null; };
+Encoder.prototype.init = function() {
+  this._position = 0;
+  this.low = 0;
+  this.range = MAX32;
+  this._cacheSize = 1;
+  this._cache = 0;
+};
+Encoder.prototype.flushData = function() {
+  for (var i=0; i<5; i++) { this.shiftLow(); }
+};
+Encoder.prototype.flushStream = function() {
+  if (this._stream.flush) { this._stream.flush(); }
+};
+Encoder.prototype.shiftLow = function() {
+  var overflow = (this.low > MAX32) ? 1 : 0;
+  if (this.low < MASK24 || overflow) {
+    this._position += this._cacheSize;
+    var temp = this._cache;
+    do {
+      this._stream.writeByte((temp + overflow) & MAX8);
+      temp = MAX8;
+    } while (--this._cacheSize !== 0);
+    this._cache = this.low >>> 24;
+  }
+  this._cacheSize++;
+  this.low = (this.low & MAX24) * 256;
+};
+Encoder.prototype.encodeDirectBits = function(v, numTotalBits) {
+  var mask = 1 << (numTotalBits-1);
+  for (var i = numTotalBits - 1; i >= 0; i--, mask>>>=1) {
+    this.range >>>= 1;
+    if (v & mask) { this.low += this.range; }
+    if (this.range <= MAX24) {
+      this.range *= 256;
+      this.shiftLow();
+    }
+  }
+};
+Encoder.prototype.getProcessedSizeAdd = function() {
+  return this._cacheSize + this._position + 4;
+};
+Encoder.initBitModels = function(probs, len) {
+  if (len && !probs) {
+    probs = typeof(Uint16Array)!=='undefined' ? new Uint16Array(len) : new Array(len);
+  }
+  for (var i=0; i < probs.length; i++) { probs[i] = (kBitModelTotal >>> 1); }
+  return probs;
+};
+Encoder.prototype.encode = function(probs, index, symbol) {
+  var prob = probs[index];
+  var newBound = (this.range >>> kNumBitModelTotalBits) * prob;
+  if (symbol === 0) {
+    this.range = newBound;
+    probs[index] = prob + ((kBitModelTotal - prob) >>> kNumMoveBits);
+  } else {
+    this.low += newBound;
+    this.range -= newBound;
+    probs[index] = prob - (prob >>> kNumMoveBits);
+  }
+  if (this.range <= MAX24) {
+    this.range *= 256;
+    this.shiftLow();
+  }
+};
+
+var ProbPrices = typeof(Uint32Array)!=='undefined' ?
+  new Uint32Array(kBitModelTotal >>> kNumMoveReducingBits) : [];
+(function() {
+  var kNumBits = (kNumBitModelTotalBits - kNumMoveReducingBits);
+  for (var i = kNumBits - 1; i >= 0; i--) {
+    var start = 1 << (kNumBits - i - 1);
+    var end = 1 << (kNumBits - i);
+    for (var j = start; j < end; j++) {
+      ProbPrices[j] = (i << kNumBitPriceShiftBits) +
+        (((end - j) << kNumBitPriceShiftBits) >>> (kNumBits - i - 1));
+    }
+  }
+})();
+
+Encoder.getPrice = function(prob, symbol) {
+  return ProbPrices[(((prob - symbol) ^ ((-symbol))) & (kBitModelTotal - 1)) >>> kNumMoveReducingBits];
+};
+Encoder.getPrice0 = function(prob) { return ProbPrices[prob >>> kNumMoveReducingBits]; };
+Encoder.getPrice1 = function(prob) { return ProbPrices[(kBitModelTotal - prob) >>> kNumMoveReducingBits]; };
+Encoder.kNumBitPriceShiftBits = kNumBitPriceShiftBits;
+
+module.exports = Encoder;

package/assets/lzma-purejs/lib/RangeCoder.js

@@ -0,0 +1,10 @@
+'use strict';
+var BitTreeDecoder = require('./RangeCoder/BitTreeDecoder');
+var Decoder = require('./RangeCoder/Decoder');
+var Encoder = require('./RangeCoder/Encoder');
+
+module.exports = {
+  BitTreeDecoder: BitTreeDecoder,
+  Decoder: Decoder,
+  Encoder: Encoder
+};