piclaw 0.0.19 → 0.0.21

package/.output/server/node_modules/compressjs/lib/FenwickModel.js

@@ -0,0 +1,194 @@
+/** Range coding model based on Fenwick trees for O(ln N) query/update. */
+if (typeof define !== 'function') { var define = require('amdefine')(module); }
+define(['./RangeCoder','./Stream','./Util'],function(RangeCoder,Stream,Util){
+
+/** We store two probabilities in a U32, so max prob is going to be 0xFFFF */
+var DEFAULT_MAX_PROB = 0xFF00;
+var DEFAULT_INCREMENT= 0x0100;
+
+var ESC_MASK = 0x0000FFFF, ESC_SHIFT = 0;
+var SYM_MASK = 0xFFFF0000, SYM_SHIFT = 16;
+var SCALE_MASK=0xFFFEFFFE;
+
+var FenwickModel = function(coder, size, max_prob, increment) {
+    this.coder = coder;
+    this.numSyms = size + 1; // save space for an escape symbol
+    this.tree = Util.makeU32Buffer(this.numSyms*2);
+    this.increment = (+increment) || DEFAULT_INCREMENT;
+    this.max_prob = (+max_prob) || DEFAULT_MAX_PROB;
+    // sanity-check to prevent overflow.
+    console.assert((this.max_prob + (this.increment-1)) <= 0xFFFF);
+    console.assert(size <= 0xFFFF);
+    // record escape probability as 1.
+    var i;
+    for (i=0; i<size; i++) {
+        this.tree[this.numSyms + i] = // escape prob=1, sym prob = 0
+            (1 << ESC_SHIFT) | (0 << SYM_SHIFT);
+    }
+    this.tree[this.numSyms + i] = // escape prob = 0, sym prob = 1
+        (0 << ESC_SHIFT) | (this.increment << SYM_SHIFT);
+    this._sumTree();
+    // probability sums are in this.tree[1].  this.tree[0] is unused.
+};
+FenwickModel.factory = function(coder, max_prob, increment) {
+    return function(size) {
+        return new FenwickModel(coder, size, max_prob, increment);
+    };
+};
+FenwickModel.prototype.clone = function() {
+    var newModel = new FenwickModel(this.coder, this.size,
+                                    this.max_prob, this.increment);
+    var i;
+    for (i=1; i<this.tree.length; i++) {
+        newModel.tree[i] = this.tree[i];
+    }
+    return newModel;
+};
+FenwickModel.prototype.encode = function(symbol) {
+    var i = this.numSyms + symbol;
+    var sy_f = this.tree[i];
+    var mask = SYM_MASK, shift = SYM_SHIFT;
+    var update = (this.increment << SYM_SHIFT);
+
+    if ((sy_f & SYM_MASK) === 0) { // escape!
+        this.encode(this.numSyms-1);
+        mask = ESC_MASK;
+        update -= (1<<ESC_SHIFT); // not going to escape no mo'
+        shift = ESC_SHIFT;
+    } else if (symbol === (this.numSyms-1) &&
+               ((this.tree[1] & ESC_MASK) >>> ESC_SHIFT) === 1) {
+        // this is the last escape, zero it out
+        update = -this.tree[i];
+    }
+    // sum up the proper lt_f
+    var lt_f = 0;
+    while (i > 1) {
+        var isRight = (i & 1);
+        var parent = (i >>> 1);
+        // if we're the right child, we need to
+        // add the prob from the left child
+        if (isRight) {
+            lt_f += this.tree[2*parent];
+        }
+        // update sums
+        this.tree[i] += update; // increase sym / decrease esc
+        i = parent;
+    }
+    var tot_f = this.tree[1];
+    this.tree[1] += update; // update prob in root
+    sy_f = (sy_f & mask) >>> shift;
+    lt_f = (lt_f & mask) >>> shift;
+    tot_f =(tot_f& mask) >>> shift;
+    this.coder.encodeFreq(sy_f, lt_f, tot_f);
+    // rescale?
+    if ((( this.tree[1] & SYM_MASK ) >>> SYM_SHIFT) >= this.max_prob) {
+        this._rescale();
+    }
+};
+FenwickModel.prototype._decode = function(isEscape) {
+    var mask = SYM_MASK, shift = SYM_SHIFT;
+    var update = (this.increment << SYM_SHIFT);
+    if (isEscape) {
+        mask = ESC_MASK;
+        update -= (1 << ESC_SHIFT);
+        shift = ESC_SHIFT;
+    }
+    var tot_f = (this.tree[1] & mask) >>> shift;
+    var prob = this.coder.decodeCulFreq(tot_f);
+    // travel down the tree looking for this
+    var i = 1, lt_f = 0;
+    while (i < this.numSyms) {
+        this.tree[i] += update;
+        // look at probability in left child.
+        var leftProb = (this.tree[2*i] & mask) >>> shift;
+        i *= 2;
+        if ((prob-lt_f) >= leftProb) {
+            lt_f += leftProb;
+            i++; // take the right child.
+        }
+    }
+    var symbol = i - this.numSyms;
+    var sy_f = (this.tree[i] & mask) >>> shift;
+    this.tree[i] += update;
+    this.coder.decodeUpdate(sy_f, lt_f, tot_f);
+    // was this the last escape?
+    if (symbol === (this.numSyms-1) &&
+        ((this.tree[1] & ESC_MASK) >>> ESC_SHIFT) === 1) {
+        update = -this.tree[i]; // zero it out
+        while (i >= 1) {
+            this.tree[i] += update;
+            i = (i >>> 1); // parent
+        }
+    }
+    // rescale?
+    if ((( this.tree[1] & SYM_MASK ) >>> SYM_SHIFT) >= this.max_prob) {
+        this._rescale();
+    }
+    return symbol;
+};
+FenwickModel.prototype.decode = function() {
+    var symbol = this._decode(false); // not escape
+    if (symbol === (this.numSyms-1)) {
+        // this was an escape!
+        symbol = this._decode(true); // an escape!
+    }
+    return symbol;
+};
+FenwickModel.prototype._rescale = function() {
+    var i, prob, noEscape = true;
+    // scale symbols (possible causing them to escape)
+    for (i=0; i < this.numSyms-1; i++) {
+        prob = this.tree[this.numSyms + i];
+        if ((prob & ESC_MASK) !== 0) {
+            // this symbol escapes
+            noEscape = false;
+            continue;
+        }
+        prob = (prob & SCALE_MASK) >>> 1;
+        if (prob === 0) {
+            // this symbol newly escapes
+            prob = (1 << ESC_SHIFT);
+            noEscape = false;
+        }
+        this.tree[this.numSyms + i] = prob;
+    }
+    // scale the escape symbol
+    prob = this.tree[this.numSyms + i];
+    prob = (prob & SCALE_MASK) >>> 1;
+    // prob should be zero if there are no escaping symbols, otherwise
+    // it must be at least 1.
+    if (noEscape) { prob = 0; }
+    else if (prob === 0) { prob = (1 << SYM_SHIFT); }
+    this.tree[this.numSyms + i] = prob;
+    // sum it all up afresh
+    this._sumTree();
+};
+FenwickModel.prototype._sumTree = function() {
+    var i;
+    // sum it all. (we know we won't overflow)
+    for (i=this.numSyms - 1; i > 0; i--) {
+        this.tree[i] = this.tree[2*i] + this.tree[2*i + 1];
+    }
+};
+
+FenwickModel.MAGIC = 'fenw';
+/** Simple order-0 compressor, as self-test. */
+FenwickModel.compressFile = Util.compressFileHelper(FenwickModel.MAGIC, function(inStream, outStream, fileSize, props, finalByte) {
+    var range = new RangeCoder(outStream);
+    range.encodeStart(finalByte, 1);
+    var model = new FenwickModel(range, (fileSize<0) ? 257 : 256);
+    Util.compressWithModel(inStream, fileSize, model);
+    range.encodeFinish();
+}, true);
+
+/** Simple order-0 decompresser, as self-test. */
+FenwickModel.decompressFile = Util.decompressFileHelper(FenwickModel.MAGIC, function(inStream, outStream, fileSize) {
+    var range = new RangeCoder(inStream);
+    range.decodeStart(true/*already read the final byte*/);
+    var model = new FenwickModel(range, (fileSize<0) ? 257 : 256);
+    Util.decompressWithModel(outStream, fileSize, model);
+    range.decodeFinish();
+});
+
+return FenwickModel;
+});

package/.output/server/node_modules/compressjs/lib/Huffman.js

@@ -0,0 +1,514 @@
+/* Adaptive Huffman code, using Vitter's algorithm ported from
+ * vitter.c at http://code.google.com/p/compression-code/downloads/list
+ * The original code was placed in the public domain, and so I
+ * also place this JavaScript port in the public domain.
+ *   -- C. Scott Ananian <cscott@cscott.net>, 2013
+ * ps. some truly grotty C code in the originally, faithfully ported to
+ *     evil comma-operator-using, assignment-in-if-condition JavaScript.
+ */
+if (typeof define !== 'function') { var define = require('amdefine')(module); }
+define(['./BitStream','./Util'],function(BitStream,Util) {
+//  This code is adapted from Professor Vitter's
+//  article, Design and Analysis of Dynamic Huffman Codes,
+//  which appeared in JACM October 1987
+
+//  A design trade-off has been made to simplify the
+//  code:  a node's block is determined dynamically,
+//  and the implicit tree structure is maintained,
+//  e.g. explicit node numbers are also implicit.
+
+//  Dynamic Huffman table weight ranking
+//  is maintained per Professor Vitter's
+//  invariant (*) for algorithm FGK:
+
+//  leaves precede internal nodes of the
+//  same weight in a non-decreasing ranking
+//  of weights using implicit node numbers:
+
+//  1) leaves slide over internal nodes, internal nodes
+//  swap over groups of leaves, leaves are swapped
+//  into group leader position, but two internal
+//  nodes never change positions relative
+//  to one another.
+
+//  2) weights are incremented by 2:
+//  leaves always have even weight values;
+//  internal nodes always have odd values.
+
+//  3) even node numbers are always right children;
+//  odd numbers are left children in the tree.
+
+//  node 2 * HuffSize - 1 is always the tree root;
+//  node HuffEsc is the escape node;
+
+//  the tree is initialized by creating an
+//  escape node as the root.
+
+//  each new leaf symbol is paired with a new escape
+//  node into the previous escape node in the tree,
+//  until the last symbol which takes over the
+//  tree position of the escape node, and
+//  HuffEsc is left at zero.
+
+//  overall table size: 2 * HuffSize
+
+//  huff_init(alphabet_size, potential symbols used)
+//  huff_encode(next_symbol)
+//  next_symbol = huff_decode()
+
+//  huff_scale(by_bits) -- scale weights and re-balance tree
+
+var HTable = function(up, down, symbol, weight) {
+    this.up = up; // next node up the tree
+    this.down = down; // pair of down nodes
+    this.symbol = symbol;       // node symbol value
+    this.weight = weight;       // node weight
+};
+HTable.prototype.clone = function() {
+  return new HTable(this.up, this.down, this.symbol, this.weight);
+};
+HTable.prototype.set = function(htable) {
+  this.up = htable.up;
+  this.down = htable.down;
+  this.symbol = htable.symbol;
+  this.weight = htable.weight;
+};
+
+//  initialize an adaptive coder
+//  for alphabet size, and count
+//  of nodes to be used
+var Huffman = function(size, root, bitstream, max_weight) {
+  var i;
+  //  default: all alphabet symbols are used
+
+  console.assert(size && typeof(size)==='number');
+  if( !root || root > size )
+      root = size;
+
+  //  create the initial escape node
+  //  at the tree root
+
+  if ( root <<= 1 ) {
+      root--;
+  }
+
+  // create root+1 htables (coding table)
+  // XXX this could be views on a backing Uint32 array?
+  this.table = [];
+  for (i=0; i<=root; i++) {
+    this.table[i] = new HTable(0,0,0,0);
+  }
+
+  // this.map => mapping for symbols to nodes
+  this.map = [];
+  // this.size => the alphabet size
+  if( this.size = size ) {
+    for (i=0; i<size; i++) {
+      this.map[i] = 0;
+    }
+  }
+
+  // this.esc  => the current tree height
+  // this.root => the root of the tree
+  this.esc = this.root = root;
+
+  if (bitstream) {
+    this.readBit = bitstream.readBit.bind(bitstream);
+    this.writeBit = bitstream.writeBit.bind(bitstream);
+  }
+  this.max_weight = max_weight; // may be null or undefined
+}
+// factory interface
+Huffman.factory = function(bitstream, max_weight) {
+  return function(size) {
+    return new Huffman(size, size, bitstream, max_weight);
+  };
+};
+
+
+// split escape node to incorporate new symbol
+
+Huffman.prototype.split = function(symbol) {
+  var pair, node;
+
+  //  is the tree already full???
+
+  if( pair = this.esc ) {
+    this.esc--;
+  } else {
+    console.assert(false);
+    return 0;
+  }
+
+  //  if this is the last symbol, it moves into
+  //  the escape node's old position, and
+  //  this.esc is set to zero.
+
+  //  otherwise, the escape node is promoted to
+  //  parent a new escape node and the new symbol.
+
+  if( node = this.esc ) {
+    this.table[pair].down = node;
+    this.table[pair].weight = 1;
+    this.table[node].up = pair;
+    this.esc--;
+  } else {
+    pair = 0;
+    node = 1;
+  }
+
+  //  initialize the new symbol node
+
+  this.table[node].symbol = symbol;
+  this.table[node].weight = 0;
+  this.table[node].down = 0;
+  this.map[symbol] = node;
+
+  //  initialize a new escape node.
+
+  this.table[this.esc].weight = 0;
+  this.table[this.esc].down = 0;
+  this.table[this.esc].up = pair;
+  return node;
+};
+
+//  swap leaf to group leader position
+//  return symbol's new node
+
+Huffman.prototype.leader = function(node) {
+  var weight = this.table[node].weight;
+  var leader = node, prev, symbol;
+
+  while( weight === this.table[leader + 1].weight ) {
+    leader++;
+  }
+
+  if( leader === node ) {
+    return node;
+  }
+
+  // swap the leaf nodes
+
+  symbol = this.table[node].symbol;
+  prev = this.table[leader].symbol;
+
+  this.table[leader].symbol = symbol;
+  this.table[node].symbol = prev;
+  this.map[symbol] = leader;
+  this.map[prev] = node;
+  return leader;
+};
+
+//  slide internal node up over all leaves of equal weight;
+//  or exchange leaf with next smaller weight internal node
+
+//  return node's new position
+
+Huffman.prototype.slide = function(node) {
+  var next = node;
+  var swap;
+
+  swap = this.table[next++].clone();
+
+  // if we're sliding an internal node, find the
+  // highest possible leaf to exchange with
+
+  if( swap.weight & 1 ) {
+    while( swap.weight > this.table[next + 1].weight ) {
+      next++;
+    }
+  }
+
+  //  swap the two nodes
+
+  this.table[node].set(this.table[next]);
+  this.table[next].set(swap);
+
+  this.table[next].up = this.table[node].up;
+  this.table[node].up = swap.up;
+
+  //  repair the symbol map and tree structure
+
+  if( swap.weight & 1 ) {
+    this.table[swap.down].up = next;
+    this.table[swap.down - 1].up = next;
+    this.map[this.table[node].symbol] = node;
+  } else {
+    this.table[this.table[node].down - 1].up = node;
+    this.table[this.table[node].down].up = node;
+    this.map[swap.symbol] = next;
+  }
+
+  return next;
+};
+
+//  increment symbol weight and re balance the tree.
+
+Huffman.prototype.increment = function(node) {
+  var up;
+
+  //  obviate swapping a parent with its child:
+  //    increment the leaf and proceed
+  //    directly to its parent.
+
+  //  otherwise, promote leaf to group leader position in the tree
+
+  if( this.table[node].up === node + 1 ) {
+    this.table[node].weight += 2;
+    node++;
+  } else {
+    node = this.leader (node);
+  }
+
+  //  increase the weight of each node and slide
+  //  over any smaller weights ahead of it
+  //  until reaching the root
+
+  //  internal nodes work upwards from
+  //  their initial positions; while
+  //  symbol nodes slide over first,
+  //  then work up from their final
+  //  positions.
+
+  while( this.table[node].weight += 2, up = this.table[node].up ) {
+    while( this.table[node].weight > this.table[node + 1].weight ) {
+        node = this.slide (node);
+    }
+
+    if( this.table[node].weight & 1 ) {
+        node = up;
+    } else {
+        node = this.table[node].up;
+    }
+  }
+
+  /* Re-scale if necessary. */
+  if (this.max_weight) {
+    if (this.table[this.root].weight >= this.max_weight) {
+      this.scale(1);
+    }
+  }
+};
+
+//  scale all weights and re-balance the tree
+
+//  zero weight nodes are removed from the tree
+//  by sliding them out the left of the rank list
+
+Huffman.prototype.scale = function(bits) {
+  var node = this.esc, weight, prev;
+
+  //  work up the tree from the escape node
+  //  scaling weights by the value of bits
+
+  while( ++node <= this.root ) {
+    //  recompute the weight of internal nodes;
+    //  slide down and out any unused ones
+
+    if( this.table[node].weight & 1 ) {
+      if( weight = this.table[this.table[node].down].weight & ~1 ) {
+        weight += this.table[this.table[node].down - 1].weight | 1;
+      }
+
+      //  remove zero weight leaves by incrementing HuffEsc
+      //  and removing them from the symbol map.  take care
+
+    } else if( !(weight = this.table[node].weight >> bits & ~1) ) {
+      if( this.map[this.table[node].symbol] = 0, this.esc++ ) {
+        this.esc++;
+      }
+    }
+
+    // slide the scaled node back down over any
+    // previous nodes with larger weights
+
+    this.table[node].weight = weight;
+    prev = node;
+
+    while( weight < this.table[--prev].weight ) {
+      this.slide(prev);
+    }
+  }
+
+  // prepare a new escape node
+
+  this.table[this.esc].down = 0;
+};
+
+//  send the bits for an escaped symbol
+
+Huffman.prototype.sendid = function(symbol) {
+  var empty = 0, max;
+
+  //  count the number of empty symbols
+  //  before the symbol in the table
+
+  while( symbol-- ) {
+    if( !this.map[symbol] ) {
+      empty++;
+    }
+  }
+
+  //  send LSB of this count first, using
+  //  as many bits as are required for
+  //  the maximum possible count
+
+  if( max = this.size - Math.floor((this.root - this.esc) / 2) - 1 ) {
+    do {
+      this.writeBit(empty & 1);
+      empty >>= 1;
+    } while( max >>= 1 );
+  }
+};
+
+//  encode the next symbol
+
+Huffman.prototype.encode = function(symbol) {
+  var emit = 1, bit;
+  var up, idx, node;
+
+  if( symbol < this.size ) {
+    node = this.map[symbol];
+  } else {
+    console.assert(false);
+    return;
+  }
+
+  //  for a new symbol, direct the receiver to the escape node
+  //  but refuse input if table is already full.
+
+  if( !(idx = node) ) {
+    if( !(idx = this.esc) ) {
+      return;
+    }
+  }
+
+  //  accumulate the code bits by
+  //  working up the tree from
+  //  the node to the root
+
+  while( up = this.table[idx].up ) {
+    emit <<= 1; emit |= idx & 1; idx = up;
+  }
+
+  //  send the code, root selector bit first
+
+  while( bit = emit & 1, emit >>= 1 ) {
+    this.writeBit(bit);
+  }
+
+  //  send identification and incorporate
+  //  new symbols into the tree
+
+  if( !node ) {
+    this.sendid(symbol);
+    node = this.split(symbol);
+  }
+
+  //  adjust and re-balance the tree
+
+  this.increment(node);
+};
+
+//  read the identification bits
+//  for an escaped symbol
+
+Huffman.prototype.readid = function() {
+  var empty = 0, bit = 1, max, symbol;
+
+  //  receive the symbol, LSB first, reading
+  //  only the number of bits necessary to
+  //  transmit the maximum possible symbol value
+
+  if( max = this.size - Math.floor((this.root - this.esc) / 2) - 1 ) {
+    do {
+      empty |= this.readBit() ? bit : 0;
+      bit <<= 1;
+    } while( max >>= 1 );
+  }
+
+  //  the count is of unmapped symbols
+  //  in the table before the new one
+
+  for( symbol = 0; symbol < this.size; symbol++ ) {
+    if( !this.map[symbol] ) {
+      if( !empty-- ) {
+        return symbol;
+      }
+    }
+  }
+
+  //  oops!  our count is too big, either due
+  //  to a bit error, or a short node count
+  //  given to huff_init.
+
+  console.assert(false);
+  return 0;
+};
+
+//  decode the next symbol
+
+Huffman.prototype.decode = function() {
+  var node = this.root;
+  var symbol, down;
+
+  //  work down the tree from the root
+  //  until reaching either a leaf
+  //  or the escape node.  A one
+  //  bit means go left, a zero
+  //  means go right.
+
+  while( down = this.table[node].down ) {
+    if( this.readBit() ) {
+      node = down - 1;  // the left child precedes the right child
+    } else {
+      node = down;
+    }
+  }
+
+  //  sent to the escape node???
+  //  refuse to add to a full tree
+
+  if( node === this.esc ) {
+    if( this.esc ) {
+      symbol = this.readid ();
+      node = this.split (symbol);
+    } else {
+      console.assert(false);
+      return 0;
+    }
+  } else {
+    symbol = this.table[node].symbol;
+  }
+
+  //  increment weights and re-balance
+  //  the coding tree
+
+  this.increment (node);
+  return symbol;
+};
+
+// stand alone compressor, mostly for testing
+Huffman.MAGIC = 'huff';
+Huffman.compressFile = Util.compressFileHelper(Huffman.MAGIC, function(input, output, size, props) {
+  var bitstream = new BitStream(output);
+
+  var alphabetSize = 256;
+  if (size < 0) { alphabetSize++; }
+  var huff = new Huffman(257, alphabetSize, bitstream, 8191);
+  Util.compressWithModel(input, size, huff);
+  bitstream.flush();
+});
+
+// stand alone decompresser, again for testing
+Huffman.decompressFile = Util.decompressFileHelper(Huffman.MAGIC, function(input, output, size) {
+  var bitstream = new BitStream(input);
+
+  var alphabetSize = 256;
+  if (size < 0) { alphabetSize++; }
+  var huff = new Huffman(257, alphabetSize, bitstream, 8191);
+  Util.decompressWithModel(output, size, huff);
+});
+
+return Huffman;
+});