piclaw 0.0.19 → 0.0.21

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

@@ -0,0 +1,420 @@
+/** Burrows-Wheeler transform, computed with the Induced Sorting Suffix Array
+ *  construction mechanism (sais).  Code is a port of:
+ *    https://sites.google.com/site/yuta256/sais
+ *  which is:
+ *    Copyright (c) 2008-2010 Yuta Mori All Rights Reserved.
+ *  and licensed under an MIT/X11 license.  I generally looked at both
+ *  the C and the Java implementations to guide my work.
+ *
+ * This JavaScript port is:
+ *    Copyright (c) 2013 C. Scott Ananian
+ * and licensed under GPLv2; see the README at the top level of this package.
+ */
+if (typeof define !== 'function') { var define = require('amdefine')(module); }
+define(['./freeze', './Util'], function(freeze, Util) {
+    var ASSERT = console.assert.bind(console);
+
+    // we're dispensing with the "arbitrary alphabet" stuff of the source
+    // and just using Uint8Arrays.
+
+    /** Find the start or end of each bucket. */
+    var getCounts = function(T, C, n, k) {
+        var i;
+        for (i = 0; i < k; i++) { C[i] = 0; }
+        for (i = 0; i < n; i++) { C[T[i]]++; }
+    };
+    var getBuckets = function(C, B, k, end) {
+        var i, sum = 0;
+        if (end) {
+            for (i = 0; i < k; i++) { sum += C[i]; B[i] = sum; }
+        } else {
+            for (i = 0; i < k; i++) { sum += C[i]; B[i] = sum - C[i]; }
+        }
+    };
+
+    /** Sort all type LMS suffixes */
+    var LMSsort = function(T, SA, C, B, n, k) {
+        var b, i, j;
+        var c0, c1;
+        /* compute SAl */
+        if (C === B) { getCounts(T, C, n, k); }
+        getBuckets(C, B, k, false); /* find starts of buckets */
+        j = n - 1;
+        b = B[c1 = T[j]];
+        j--;
+        SA[b++] = (T[j] < c1) ? ~j : j;
+        for (i = 0; i < n; i++) {
+            if ((j = SA[i]) > 0) {
+                ASSERT(T[j] >= T[j+1]);
+                if ((c0 = T[j]) !== c1) { B[c1] = b; b = B[c1 = c0]; }
+                ASSERT(i < b);
+                j--;
+                SA[b++] = (T[j] < c1) ? ~j : j;
+                SA[i] = 0;
+            } else if (j < 0) {
+                SA[i] = ~j;
+            }
+        }
+        /* compute SAs */
+        if (C === B) { getCounts(T, C, n, k); }
+        getBuckets(C, B, k, 1); /* find ends of buckets */
+        for (i = n-1, b = B[c1 = 0]; i >= 0; i--) {
+            if ((j = SA[i]) > 0) {
+                ASSERT(T[j] <= T[j+1]);
+                if ((c0 = T[j]) !== c1) { B[c1] = b; b = B[c1 = c0]; }
+                ASSERT(b <= i);
+                j--;
+                SA[--b] = (T[j] > c1) ? ~(j+1) : j;
+                SA[i] = 0;
+            }
+        }
+    };
+
+    var LMSpostproc = function(T, SA, n, m) {
+        var i, j, p, q, plen, qlen, name;
+        var c0, c1;
+        var diff;
+
+        /* compact all the sorted substrings into the first m items of SA
+         * 2*m must not be larger than n (provable) */
+        ASSERT(n > 0);
+        for (i = 0; (p = SA[i]) < 0; i++) { SA[i] = ~p; ASSERT((i+1) < n); }
+        if (i < m) {
+            for (j = i, i++; ; i++) {
+                ASSERT(i < n);
+                if ((p = SA[i]) < 0) {
+                    SA[j++] = ~p; SA[i] = 0;
+                    if (j === m) { break; }
+                }
+            }
+        }
+
+        /* store the length of all substrings */
+        c0 = T[i = j = n - 1];
+        do { c1 = c0; } while ( ((--i) >= 0 ) && ((c0=T[i]) >= c1) );
+        for (; i >= 0; ) {
+            do { c1 = c0; } while ( ((--i) >= 0 ) && ((c0=T[i]) <= c1) );
+            if (i >= 0) {
+                SA[m + ((i + 1) >>> 1)] = j - i; j = i + 1;
+                do { c1 = c0; } while ( ((--i) >= 0 ) && ((c0=T[i]) >= c1) );
+            }
+        }
+
+        /* find the lexicographic names of all substrings */
+        for (i = 0, name = 0, q = n, qlen = 0; i < m; i++) {
+            p = SA[i]; plen = SA[m + (p >>> 1)]; diff = true;
+            if ((plen === qlen) && ((q + plen) < n)) {
+                for (j = 0; (j < plen) && (T[p + j] === T[q + j]); ) { j++; }
+                if (j === plen) { diff = false; }
+            }
+            if (diff) { name++; q = p; qlen = plen; }
+            SA[m + (p >>> 1)] = name;
+        }
+
+        return name;
+    };
+
+    /* compute SA and BWT */
+    var induceSA = function(T, SA, C, B, n, k) {
+        var b, i, j;
+        var c0, c1;
+        /* compute SAl */
+        if (C === B) { getCounts(T, C, n, k); }
+        getBuckets(C, B, k, false); /* find starts of buckets */
+        j = n - 1;
+        b = B[c1 = T[j]];
+        SA[b++] = ((j > 0) && (T[j-1] < c1)) ? ~j : j;
+        for (i = 0; i < n; i++) {
+            j = SA[i]; SA[i] = ~j;
+            if (j > 0) {
+                j--;
+                ASSERT( T[j] >= T[j + 1] );
+                if ((c0 = T[j]) !== c1) { B[c1]  = b; b = B[c1=c0]; }
+                ASSERT( i < b );
+                SA[b++] = ((j > 0) && (T[j-1] < c1)) ? ~j : j;
+            }
+        }
+        /* compute SAs */
+        if (C === B) { getCounts(T, C, n, k); }
+        getBuckets(C, B, k, true); /* find ends of buckets */
+        for (i = n-1, b = B[c1 = 0]; i >= 0; i--) {
+            if ((j = SA[i]) > 0) {
+                j--;
+                ASSERT( T[j] <= T[j + 1] );
+                if ((c0 = T[j]) !== c1) { B[c1] = b; b = B[c1 = c0]; }
+                ASSERT( b <= i );
+                SA[--b] = ((j === 0) || (T[j - 1] > c1)) ? ~j : j;
+            } else {
+                SA[i] = ~j;
+            }
+        }
+    };
+
+    var computeBWT = function(T, SA, C, B, n, k) {
+        var b, i, j, pidx = -1;
+        var c0, c1;
+        /* compute SAl */
+        if (C === B) { getCounts(T, C, n, k); }
+        getBuckets(C, B, k, false); /* find starts of buckets */
+        j = n - 1;
+        b = B[c1 = T[j]];
+        SA[b++] = ((j > 0) && (T[j - 1] < c1)) ? ~j : j;
+        for (i = 0; i < n; i++) {
+            if ((j=SA[i]) > 0) {
+                j--;
+                ASSERT( T[j] >= T[j+1] );
+                SA[i] = ~(c0 = T[j]);
+                if (c0 !== c1) { B[c1] = b; b = B[c1 = c0]; }
+                ASSERT( i < b );
+                SA[b++] = ((j > 0) && (T[j - 1] < c1)) ? ~j : j;
+            } else if (j !== 0) {
+                SA[i] = ~j;
+            }
+        }
+        /* compute SAs */
+        if (C === B) { getCounts(T, C, n, k); }
+        getBuckets(C, B, k, true); /* find ends of buckets */
+        for (i = n-1, b = B[c1 = 0]; i >= 0; i--) {
+            if ((j = SA[i]) > 0) {
+                j--;
+                ASSERT( T[j] <= T[j+1] );
+                SA[i] = c0 = T[j];
+                if (c0 !== c1) { B[c1] = b; b = B[c1 = c0]; }
+                ASSERT( b <= i );
+                SA[--b] = ((j > 0) && (T[j-1] > c1)) ? (~T[j-1]) : j;
+            } else if (j !== 0) {
+                SA[i] = ~j;
+            } else {
+                pidx = i;
+            }
+        }
+        return pidx;
+    };
+
+    /* find the suffix array SA of T[0..n-1] in {0..k-1}^n
+       use a working space (excluding T and SA) of at most 2n+O(1) for a
+       constant alphabet */
+    var SA_IS = function(T, SA, fs, n, k, isbwt) {
+        var C, B, RA;
+        var i, j, b, c, m, p, q, name, pidx = 0, newfs;
+        var c0, c1;
+        var flags = 0;
+
+        // allocate temporary storage [CSA]
+        if (k <= 256) {
+            C = Util.makeS32Buffer(k);
+            if (k <= fs) { B = SA.subarray(n + fs - k); flags = 1; }
+            else { B = Util.makeS32Buffer(k); flags = 3; }
+        } else if (k <= fs) {
+            C = SA.subarray(n + fs - k);
+            if (k <= (fs - k)) { B = SA.subarray(n + fs - k * 2); flags = 0; }
+            else if (k <= 1024) { B = Util.makeS32Buffer(k); flags = 2; }
+            else { B = C; flags = 8; }
+        } else {
+            C = B = Util.makeS32Buffer(k);
+            flags = 4 | 8;
+        }
+
+        /* stage 1: reduce the problem by at least 1/2
+           sort all the LMS-substrings */
+        getCounts(T, C, n, k);
+        getBuckets(C, B, k, true); /* find ends of buckets */
+        for (i = 0; i < n; i++) { SA[i] = 0; }
+        b = -1; i = n - 1; j = n; m = 0; c0 = T[n - 1];
+        do { c1 = c0; } while ((--i >= 0) && ((c0 = T[i]) >= c1));
+        for (; i >= 0 ;) {
+            do { c1 = c0; } while ((--i >= 0) && ((c0 = T[i]) <= c1));
+            if ( i >= 0 ) {
+                if ( b >= 0 ) { SA[b] = j; }
+                b = --B[c1];
+                j = i;
+                ++m;
+                do { c1 = c0; } while ((--i >= 0) && ((c0 = T[i]) >= c1));
+            }
+        }
+
+        if (m > 1) {
+            LMSsort(T, SA, C, B, n, k);
+            name = LMSpostproc(T, SA, n, m);
+        } else if (m === 1) {
+            SA[b] = j + 1;
+            name = 1;
+        } else {
+            name = 0;
+        }
+
+        /* stage 2: solve the reduced problem
+           recurse if names are not yet unique */
+        if(name < m) {
+            if((flags & 4) !== 0) { C = null; B = null; }
+            if((flags & 2) !== 0) { B = null; }
+            newfs = (n + fs) - (m * 2);
+            if((flags & (1 | 4 | 8)) === 0) {
+                if((k + name) <= newfs) { newfs -= k; }
+                else { flags |= 8; }
+            }
+            ASSERT( (n >>> 1) <= (newfs + m) );
+            for (i = m + (n >>> 1) - 1, j = m * 2 + newfs - 1; m <= i; i--) {
+                if(SA[i] !== 0) { SA[j--] = SA[i] - 1; }
+            }
+            RA = SA.subarray(m + newfs);
+            SA_IS(RA, SA, newfs, m, name, false);
+            RA = null;
+
+            i = n - 1; j = m * 2 - 1; c0 = T[n - 1];
+            do { c1 = c0; } while ((--i >= 0) && ((c0 = T[i]) >= c1));
+            for (; i >= 0 ;) {
+                do { c1 = c0; } while ((--i >= 0) && ((c0 = T[i]) <= c1));
+                if ( i >= 0 ) {
+                    SA[j--] = i + 1;
+                    do { c1 = c0; } while ((--i >= 0) && ((c0 = T[i]) >= c1));
+                }
+            }
+
+            for (i = 0; i < m; i++) { SA[i] = SA[m + SA[i]]; }
+            if((flags & 4) !== 0) { C = B = Util.makeS32Buffer(k); }
+            if((flags & 2) !== 0) { B = Util.makeS32Buffer(k); }
+        }
+
+        /* stage 3: induce the result for the original problem */
+        if((flags & 8) !== 0) { getCounts(T, C, n, k); }
+        /* put all left-most S characters into their buckets */
+        if (m > 1) {
+            getBuckets(C, B, k, true); /* find ends of buckets */
+            i = m - 1; j = n; p = SA[m - 1]; c1 = T[p];
+            do {
+                q = B[c0 = c1];
+                while (q < j) { SA[--j] = 0; }
+                do {
+                    SA[--j] = p;
+                    if(--i < 0) { break; }
+                    p = SA[i];
+                } while((c1 = T[p]) === c0);
+            } while (i >= 0 );
+            while ( j > 0 ) { SA[--j] = 0; }
+        }
+        if (!isbwt) { induceSA(T, SA, C, B, n, k); }
+        else { pidx = computeBWT(T, SA, C, B, n, k); }
+        C = null; B = null;
+        return pidx;
+    };
+
+    var BWT = Object.create(null);
+    /** SA should be a Int32Array (signed!); T can be any typed array.
+     *  alphabetSize is optional if T is an Uint8Array or Uint16Array. */
+    BWT.suffixsort = function(T, SA, n, alphabetSize) {
+        ASSERT( T && SA && T.length >= n && SA.length >= n );
+        if (n <= 1) {
+            if (n === 1) { SA[0] = 0; }
+            return 0;
+        }
+        if (!alphabetSize) {
+            if (T.BYTES_PER_ELEMENT === 1) { alphabetSize = 256; }
+            else if (T.BYTES_PER_ELEMENT === 2) { alphabetSize = 65536; }
+            else throw new Error('Need to specify alphabetSize');
+        }
+        ASSERT( alphabetSize > 0 );
+        if (T.BYTES_PER_ELEMENT) {
+            ASSERT( alphabetSize <= (1 << (T.BYTES_PER_ELEMENT*8) ) );
+        }
+        return SA_IS(T, SA, 0, n, alphabetSize, false);
+    };
+    /** Burrows-Wheeler Transform.
+        A should be Int32Array (signed!); T can be any typed array.
+        U is the same type as T (it is used for output).
+        alphabetSize is optional if T is an Uint8Array or Uint16Array.
+        ASSUMES STRING IS TERMINATED WITH AN EOF CHARACTER.
+    */
+    BWT.bwtransform = function(T, U, A, n, alphabetSize) {
+        var i, pidx;
+        ASSERT( T && U && A );
+        ASSERT( T.length >= n && U.length >= n && A.length >= n );
+        if (n <= 1) {
+            if (n === 1) { U[0] = T[0]; }
+            return n;
+        }
+        if (!alphabetSize) {
+            if (T.BYTES_PER_ELEMENT === 1) { alphabetSize = 256; }
+            else if (T.BYTES_PER_ELEMENT === 2) { alphabetSize = 65536; }
+            else throw new Error('Need to specify alphabetSize');
+        }
+        ASSERT( alphabetSize > 0 );
+        if (T.BYTES_PER_ELEMENT) {
+            ASSERT( alphabetSize <= (1 << (T.BYTES_PER_ELEMENT*8) ) );
+        }
+        pidx = SA_IS(T, A, 0, n, alphabetSize, true);
+        U[0] = T[n - 1];
+        for (i = 0; i < pidx ; i++) { U[i + 1] = A[i]; }
+        for (i += 1; i < n; i++) { U[i] = A[i]; }
+        return pidx + 1;
+    };
+    /** Reverses transform above. (ASSUMED STRING IS TERMINATED WITH EOF.) */
+    BWT.unbwtransform = function(T, U, LF, n, pidx) {
+        var C = Util.makeU32Buffer(256);
+        var i, t;
+        for (i=0; i<256; i++) { C[i] = 0; }
+        for (i=0; i<n; i++) { LF[i] = C[T[i]]++; }
+        for (i=0, t=0; i<256; i++) { t += C[i]; C[i] = t - C[i]; }
+        for (i=n-1, t=0; i>=0; i--) {
+            t = LF[t] + C[U[i]=T[t]];
+            t += (t<pidx) ? 1 : 0;
+        }
+        C = null;
+    };
+
+    /** Burrows-Wheeler Transform.
+        A should be Int32Array (signed!); T can be any typed array.
+        U is the same type as T (it is used for output).
+        alphabetSize is optional if T is an Uint8Array or Uint16Array.
+        ASSUMES STRING IS CYCLIC.
+        (XXX: this is twice as inefficient as I'd like! [CSA])
+    */
+    BWT.bwtransform2 = function(T, U, n, alphabetSize) {
+        var i, j, pidx = 0;
+        ASSERT( T && U );
+        ASSERT( T.length >= n && U.length >= n );
+        if (n <= 1) {
+            if (n === 1) { U[0] = T[0]; }
+            return 0;
+        }
+        if (!alphabetSize) {
+            if (T.BYTES_PER_ELEMENT === 1) { alphabetSize = 256; }
+            else if (T.BYTES_PER_ELEMENT === 2) { alphabetSize = 65536; }
+            else throw new Error('Need to specify alphabetSize');
+        }
+        ASSERT( alphabetSize > 0 );
+        if (T.BYTES_PER_ELEMENT) {
+            ASSERT( alphabetSize <= (1 << (T.BYTES_PER_ELEMENT*8) ) );
+        }
+        // double length of T
+        var TT;
+        if (T.length >= n*2) {
+            TT = T; // do it in place if possible
+        } else if (alphabetSize <= 256) {
+            TT = Util.makeU8Buffer(n*2);
+        } else if (alphabetSize <= 65536) {
+            TT = Util.makeU16Buffer(n*2);
+        } else {
+            TT = Util.makeU32Buffer(n*2);
+        }
+        if (TT!==T) {
+            for (i=0; i<n; i++) { TT[i] = T[i]; }
+        }
+        for (i=0; i<n; i++) { TT[n+i] = TT[i]; }
+        // sort doubled string
+        var A = Util.makeS32Buffer(n*2);
+        SA_IS(TT, A, 0, n*2, alphabetSize, false);
+        for (i=0, j=0; i<2*n; i++) {
+            var s = A[i];
+            if (s < n) {
+                if (s === 0) { pidx = j; }
+                if (--s < 0) { s = n-1; }
+                U[j++] = T[s];
+            }
+        }
+        ASSERT(j===n);
+        return pidx;
+    };
+
+    return freeze(BWT);
+});

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

@@ -0,0 +1,234 @@
+/* A simple bzip-like BWT compressor with a range encoder; written as a
+ * self-test of the BWT package. */
+if (typeof define !== 'function') { var define = require('amdefine')(module); }
+define(['./freeze','./BWT','./DefSumModel','./FenwickModel','./LogDistanceModel','./NoModel','./RangeCoder','./Stream','./Util'], function(freeze, BWT, DefSumModel, FenwickModel, LogDistanceModel, NoModel, RangeCoder, Stream, Util) {
+    var EOF = Stream.EOF;
+
+    var F_PROB_MAX  = 0xFF00;
+    var F_PROB_INCR = 0x0100;
+
+    BWTC = Object.create(null);
+    BWTC.MAGIC = "bwtc";
+    BWTC.compressFile = Util.compressFileHelper(BWTC.MAGIC, function(input, output, size, props, finalByte) {
+        var encoder = new RangeCoder(output);
+        encoder.encodeStart(finalByte, 1);
+
+        var blockSize = 9;
+        if (typeof(props)==='number' && props >= 1 && props <= 9) {
+            blockSize = props;
+        }
+        encoder.encodeByte(blockSize);
+        var fast = (blockSize <= 5);
+        blockSize *= 100000;
+
+        var block = Util.makeU8Buffer(blockSize);
+        var readBlock = function() {
+            var pos;
+            for (pos=0; pos < blockSize; ) {
+                var ch = input.readByte();
+                if (ch < 0) { break; }
+                block[pos++] = ch;
+            }
+            return pos;
+        };
+        var U = Util.makeU8Buffer(blockSize);
+        var A = Util.makeS32Buffer(blockSize);
+        var M = Util.makeU8Buffer(256); // move to front array
+        var bitModelFactory = NoModel.factory(encoder);
+        var lenModel = new LogDistanceModel(blockSize, 0,
+                                            bitModelFactory,
+                                            bitModelFactory);
+        var length, b, c, pidx, i, j;
+        do {
+            length = readBlock();
+            if (length === 0) { break; }
+            // indicate that there's another block comin'
+            // and encode the length of the block if necessary
+            if (length === block.length) {
+                encoder.encodeFreq(1, 0, 3); // "full size block"
+                b = block;
+            } else {
+                encoder.encodeFreq(1, 1, 3); // "short block"
+                lenModel.encode(length);
+                b = block.subarray(0, length);
+            }
+            pidx = BWT.bwtransform(b, U, A, length, 256);
+            lenModel.encode(pidx); // starting index
+            // encode the alphabet subset used
+            var useTree = Util.makeU16Buffer(512);
+            for (i=0; i<length; i++) {
+                c = U[i];
+                useTree[256+c] = 1;
+            }
+            for (i=255; i>0; i--) { // sum all the way up the tree
+                useTree[i] = useTree[2*i] + useTree[2*i + 1];
+            }
+            useTree[0] = 1; // sentinel
+            for (i=1; i<512; i++) {
+                var parent = i>>>1;
+                var full = 1 << (9-Util.fls(i));
+                if (useTree[parent] === 0 || useTree[parent] === (full*2)) {
+                    /* already known full/empty */
+                } else if (i >= 256) {
+                    encoder.encodeBit(useTree[i]); // leaf node
+                } else {
+                    var v = useTree[i];
+                    v = (v===0) ? 0 : (v===full) ? 2 : 1;
+                    encoder.encodeFreq(1, v, 3);
+                }
+            }
+            // remap symbols to this subset
+            var alphabetSize = 0;
+            for (i=0; i<256; i++) {
+                if (useTree[256+i]) { // symbol in use
+                    M[alphabetSize++] = i;
+                }
+            }
+            useTree = null;
+            // MTF encoding of U
+            for (i=0; i<length; i++) {
+                c = U[i];
+                for (j=0; j<alphabetSize; j++) {
+                    if (M[j] === c) {
+                        break;
+                    }
+                }
+                console.assert(j<alphabetSize);
+                U[i] = j;
+                // move to front
+                for (; j>0; j--) {
+                    M[j] = M[j-1];
+                }
+                M[0] = c;
+            }
+            // RLE/range encoding
+            var model = new FenwickModel(encoder, alphabetSize+1,
+                                         F_PROB_MAX, F_PROB_INCR);
+            if (fast) { model = new DefSumModel(encoder, alphabetSize+1); }
+            var runLength = 0;
+            var emitLastRun = function() {
+                // binary encode runs of zeros
+                while (runLength !== 0) {
+                    if (runLength&1) {
+                        model.encode(0); // RUNA
+                        runLength-=1;
+                    } else {
+                        model.encode(1); // RUNB
+                        runLength-=2;
+                    }
+                    runLength >>>= 1;
+                }
+            };
+            for (i=0; i<length; i++) {
+                c = U[i];
+                if (c === 0) {
+                    runLength++;
+                } else {
+                    emitLastRun();
+                    model.encode(c+1);
+                    // reset for next
+                    runLength = 0;
+                }
+            }
+            emitLastRun();
+            // done with this block!
+        } while (length === block.length);
+
+        encoder.encodeFreq(1, 2, 3); // "no more blocks"
+        encoder.encodeFinish();
+    }, true);
+
+    BWTC.decompressFile = Util.decompressFileHelper(BWTC.MAGIC, function(input, output, size) {
+        var decoder = new RangeCoder(input);
+        decoder.decodeStart(true/* already read the extra byte */);
+        var blockSize = decoder.decodeByte();
+        console.assert(blockSize >= 1 && blockSize <= 9);
+        var fast = (blockSize <= 5);
+        blockSize *= 100000;
+
+        var block = Util.makeU8Buffer(blockSize);
+        var U = Util.makeU8Buffer(blockSize);
+        var A = Util.makeS32Buffer(blockSize);
+        var M = Util.makeU8Buffer(256); // move to front array
+        var bitModelFactory = NoModel.factory(decoder);
+        var lenModel = new LogDistanceModel(blockSize, 0,
+                                            bitModelFactory,
+                                            bitModelFactory);
+        var b, length, i, j, c;
+        while (true) {
+            var blockIndicator = decoder.decodeCulFreq(3);
+            decoder.decodeUpdate(1, blockIndicator, 3);
+            if (blockIndicator === 0) { // full-length block
+                length = blockSize;
+                b = block;
+            } else if (blockIndicator === 1) { // short block
+                length = lenModel.decode();
+                b = block.subarray(0, length);
+            } else if (blockIndicator === 2) { // all done, no more blocks
+                break;
+            }
+            // read starting index for unBWT
+            var pidx = lenModel.decode();
+            // decode the alphabet subset used
+            var useTree = Util.makeU16Buffer(512);
+            useTree[0] = 1; // sentinel
+            for (i=1; i<512; i++) {
+                var parent = i>>>1;
+                var full = 1 << (9-Util.fls(i));
+                if (useTree[parent] === 0 || useTree[parent] === (full*2)) {
+                    /* already known full/empty */
+                    useTree[i] = useTree[parent] >>> 1;
+                } else if (i >= 256) {
+                    useTree[i] = decoder.decodeBit(); // leaf node
+                } else {
+                    var v = decoder.decodeCulFreq(3);
+                    decoder.decodeUpdate(1, v, 3);
+                    useTree[i] = (v===2) ? full : v;
+                }
+            }
+            // remap symbols to this subset
+            var alphabetSize = 0;
+            for (i=0; i<256; i++) {
+                if (useTree[256+i]) { // symbol in use
+                    M[alphabetSize++] = i;
+                }
+            }
+            useTree = null;
+            // RLE/range decoding
+            var model = new FenwickModel(decoder, alphabetSize+1,
+                                         F_PROB_MAX, F_PROB_INCR);
+            if (fast) { model = new DefSumModel(decoder, alphabetSize+1, true);}
+            var val = 1; // repeat count
+            for (i=0; i<length; ) {
+                c = model.decode();
+                if (c===0) {
+                    for (j=0; j<val; j++) { b[i++] = 0; }
+                    val *= 2;
+                } else if (c===1) {
+                    for (j=0; j<val; j++) { b[i++] = 0; b[i++] = 0; }
+                    val *= 2;
+                } else {
+                    val = 1;
+                    b[i++] = c-1;
+                }
+            }
+            // MTF decode
+            for (i=0; i<length; i++) {
+                j = b[i];
+                b[i] = c = M[j];
+                // move to front
+                for (; j>0; j--) {
+                    M[j] = M[j-1];
+                }
+                M[0] = c;
+            }
+            // unBWT
+            BWT.unbwtransform(block, U, A, length, pidx);
+            // emit!
+            output.write(U, 0, length);
+        }
+        decoder.decodeFinish();
+    });
+
+    return BWTC;
+});