7z-iterator 1.1.2 → 1.2.0

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

@@ -1,328 +0,0 @@
-'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;
-  // Lazy allocation: only create coders array, allocate individual coders on demand
-  // This saves significant memory for archives that don't use all coder slots
-  this._coders = [];
-  this._coderCount = 1 << (this._numPrevBits + this._numPosBits);
-};
-
-LiteralDecoder.prototype.init = function(){
-  // Only init coders that have been allocated (lazy allocation support)
-  for (var i = 0; i < this._coders.length; i++){
-    if (this._coders[i]) {
-      this._coders[i].init();
-    }
-  }
-};
-
-LiteralDecoder.prototype.getDecoder = function(pos, prevByte){
-  var index = ((pos & this._posMask) << this._numPrevBits) +
-              ((prevByte & 0xff) >>> (8 - this._numPrevBits));
-  // Lazy allocation: create coder on first access
-  if (!this._coders[index]) {
-    this._coders[index] = new LiteralDecoder.Decoder2();
-  }
-  return this._coders[index];
-};
-
-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.resetProbabilities = function() {
-  // Reset probability tables (same as init() but without dictionary/stream reset)
-  // Used for LZMA2 control bytes 0xa0-0xdf (state reset without dictionary reset)
-  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 = this._posSlotDecoder.length - 1; i >= 0; i--) {
-    this._posSlotDecoder[i].init();
-  }
-  this._lenDecoder.init();
-  this._repLenDecoder.init();
-  this._posAlignDecoder.init();
-  // Reset state variables
-  this._state = 0;
-  this._rep0 = 0;
-  this._rep1 = 0;
-  this._rep2 = 0;
-  this._rep3 = 0;
-  // DO NOT reset _nowPos64, _prevByte, or dictionary
-};
-
-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

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

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

@@ -1,41 +0,0 @@
-'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

@@ -1,58 +0,0 @@
-'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

@@ -1,106 +0,0 @@
-'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

@@ -1,10 +0,0 @@
-'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
-};

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

@@ -1,41 +0,0 @@
-'use strict';
-
-/* very simple input/output stream interface */
-var Stream = function() {
-};
-
-// input streams //////////////
-Stream.prototype.readByte = function() {
-  throw new Error("abstract method readByte() not implemented");
-};
-Stream.prototype.read = function(buffer, bufOffset, length) {
-  var bytesRead = 0;
-  while (bytesRead < length) {
-    var c = this.readByte();
-    if (c < 0) {
-      return (bytesRead===0) ? -1 : bytesRead;
-    }
-    buffer[bufOffset++] = c;
-    bytesRead++;
-  }
-  return bytesRead;
-};
-Stream.prototype.seek = function(new_pos) {
-  throw new Error("abstract method seek() not implemented");
-};
-
-// output streams ///////////
-Stream.prototype.writeByte = function(_byte) {
-  throw new Error("abstract method writeByte() not implemented");
-};
-Stream.prototype.write = function(buffer, bufOffset, length) {
-  var i;
-  for (i=0; i<length; i++) {
-    this.writeByte(buffer[bufOffset++]);
-  }
-  return length;
-};
-Stream.prototype.flush = function() {
-};
-
-module.exports = Stream;