novnc-rails 0.1

data/vendor/assets/javascripts/noVNC/input.js

@@ -0,0 +1,388 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2012 Joel Martin
+ * Copyright (C) 2013 Samuel Mannehed for Cendio AB
+ * Licensed under MPL 2.0 or any later version (see LICENSE.txt)
+ */
+
+/*jslint browser: true, white: false */
+/*global window, Util */
+
+var Keyboard, Mouse;
+
+(function () {
+    "use strict";
+
+    //
+    // Keyboard event handler
+    //
+
+    Keyboard = function (defaults) {
+        this._keyDownList = [];         // List of depressed keys
+                                        // (even if they are happy)
+
+        Util.set_defaults(this, defaults, {
+            'target': document,
+            'focused': true
+        });
+
+        // create the keyboard handler
+        this._handler = new KeyEventDecoder(kbdUtil.ModifierSync(),
+            VerifyCharModifier( /* jshint newcap: false */
+                TrackKeyState(
+                    EscapeModifiers(this._handleRfbEvent.bind(this))
+                )
+            )
+        ); /* jshint newcap: true */
+
+        // keep these here so we can refer to them later
+        this._eventHandlers = {
+            'keyup': this._handleKeyUp.bind(this),
+            'keydown': this._handleKeyDown.bind(this),
+            'keypress': this._handleKeyPress.bind(this),
+            'blur': this._allKeysUp.bind(this)
+        };
+    };
+
+    Keyboard.prototype = {
+        // private methods
+
+        _handleRfbEvent: function (e) {
+            if (this._onKeyPress) {
+                Util.Debug("onKeyPress " + (e.type == 'keydown' ? "down" : "up") +
+                           ", keysym: " + e.keysym.keysym + "(" + e.keysym.keyname + ")");
+                this._onKeyPress(e.keysym.keysym, e.type == 'keydown');
+            }
+        },
+
+        _handleKeyDown: function (e) {
+            if (!this._focused) { return true; }
+
+            if (this._handler.keydown(e)) {
+                // Suppress bubbling/default actions
+                Util.stopEvent(e);
+                return false;
+            } else {
+                // Allow the event to bubble and become a keyPress event which
+                // will have the character code translated
+                return true;
+            }
+        },
+
+        _handleKeyPress: function (e) {
+            if (!this._focused) { return true; }
+
+            if (this._handler.keypress(e)) {
+                // Suppress bubbling/default actions
+                Util.stopEvent(e);
+                return false;
+            } else {
+                // Allow the event to bubble and become a keyPress event which
+                // will have the character code translated
+                return true;
+            }
+        },
+
+        _handleKeyUp: function (e) {
+            if (!this._focused) { return true; }
+
+            if (this._handler.keyup(e)) {
+                // Suppress bubbling/default actions
+                Util.stopEvent(e);
+                return false;
+            } else {
+                // Allow the event to bubble and become a keyPress event which
+                // will have the character code translated
+                return true;
+            }
+        },
+
+        _allKeysUp: function () {
+            Util.Debug(">> Keyboard.allKeysUp");
+            this._handler.releaseAll();
+            Util.Debug("<< Keyboard.allKeysUp");
+        },
+
+        // Public methods
+
+        grab: function () {
+            //Util.Debug(">> Keyboard.grab");
+            var c = this._target;
+
+            Util.addEvent(c, 'keydown', this._eventHandlers.keydown);
+            Util.addEvent(c, 'keyup', this._eventHandlers.keyup);
+            Util.addEvent(c, 'keypress', this._eventHandlers.keypress);
+
+            // Release (key up) if window loses focus
+            Util.addEvent(window, 'blur', this._eventHandlers.blur);
+
+            //Util.Debug("<< Keyboard.grab");
+        },
+
+        ungrab: function () {
+            //Util.Debug(">> Keyboard.ungrab");
+            var c = this._target;
+
+            Util.removeEvent(c, 'keydown', this._eventHandlers.keydown);
+            Util.removeEvent(c, 'keyup', this._eventHandlers.keyup);
+            Util.removeEvent(c, 'keypress', this._eventHandlers.keypress);
+            Util.removeEvent(window, 'blur', this._eventHandlers.blur);
+
+            // Release (key up) all keys that are in a down state
+            this._allKeysUp();
+
+            //Util.Debug(">> Keyboard.ungrab");
+        },
+
+        sync: function (e) {
+            this._handler.syncModifiers(e);
+        }
+    };
+
+    Util.make_properties(Keyboard, [
+        ['target',     'wo', 'dom'],  // DOM element that captures keyboard input
+        ['focused',    'rw', 'bool'], // Capture and send key events
+
+        ['onKeyPress', 'rw', 'func'] // Handler for key press/release
+    ]);
+
+    //
+    // Mouse event handler
+    //
+
+    Mouse = function (defaults) {
+        this._mouseCaptured  = false;
+
+        this._doubleClickTimer = null;
+        this._lastTouchPos = null;
+
+        // Configuration attributes
+        Util.set_defaults(this, defaults, {
+            'target': document,
+            'focused': true,
+            'scale': 1.0,
+            'touchButton': 1
+        });
+
+        this._eventHandlers = {
+            'mousedown': this._handleMouseDown.bind(this),
+            'mouseup': this._handleMouseUp.bind(this),
+            'mousemove': this._handleMouseMove.bind(this),
+            'mousewheel': this._handleMouseWheel.bind(this),
+            'mousedisable': this._handleMouseDisable.bind(this)
+        };
+    };
+
+    Mouse.prototype = {
+        // private methods
+        _captureMouse: function () {
+            // capturing the mouse ensures we get the mouseup event
+            if (this._target.setCapture) {
+                this._target.setCapture();
+            }
+
+            // some browsers give us mouseup events regardless,
+            // so if we never captured the mouse, we can disregard the event
+            this._mouseCaptured = true;
+        },
+
+        _releaseMouse: function () {
+            if (this._target.releaseCapture) {
+                this._target.releaseCapture();
+            }
+            this._mouseCaptured = false;
+        },
+
+        _resetDoubleClickTimer: function () {
+            this._doubleClickTimer = null;
+        },
+
+        _handleMouseButton: function (e, down) {
+            if (!this._focused) { return true; }
+
+            if (this._notify) {
+                this._notify(e);
+            }
+
+            var evt = (e ? e : window.event);
+            var pos = Util.getEventPosition(e, this._target, this._scale);
+
+            var bmask;
+            if (e.touches || e.changedTouches) {
+                // Touch device
+
+                // When two touches occur within 500 ms of each other and are
+                // closer than 20 pixels together a double click is triggered.
+                if (down == 1) {
+                    if (this._doubleClickTimer === null) {
+                        this._lastTouchPos = pos;
+                    } else {
+                        clearTimeout(this._doubleClickTimer);
+
+                        // When the distance between the two touches is small enough
+                        // force the position of the latter touch to the position of
+                        // the first.
+
+                        var xs = this._lastTouchPos.x - pos.x;
+                        var ys = this._lastTouchPos.y - pos.y;
+                        var d = Math.sqrt((xs * xs) + (ys * ys));
+
+                        // The goal is to trigger on a certain physical width, the
+                        // devicePixelRatio brings us a bit closer but is not optimal.
+                        if (d < 20 * window.devicePixelRatio) {
+                            pos = this._lastTouchPos;
+                        }
+                    }
+                    this._doubleClickTimer = setTimeout(this._resetDoubleClickTimer.bind(this), 500);
+                }
+                bmask = this._touchButton;
+                // If bmask is set
+            } else if (evt.which) {
+                /* everything except IE */
+                bmask = 1 << evt.button;
+            } else {
+                /* IE including 9 */
+                bmask = (evt.button & 0x1) +      // Left
+                        (evt.button & 0x2) * 2 +  // Right
+                        (evt.button & 0x4) / 2;   // Middle
+            }
+
+            if (this._onMouseButton) {
+                Util.Debug("onMouseButton " + (down ? "down" : "up") +
+                           ", x: " + pos.x + ", y: " + pos.y + ", bmask: " + bmask);
+                this._onMouseButton(pos.x, pos.y, down, bmask);
+            }
+            Util.stopEvent(e);
+            return false;
+        },
+
+        _handleMouseDown: function (e) {
+            this._captureMouse();
+            this._handleMouseButton(e, 1);
+        },
+
+        _handleMouseUp: function (e) {
+            if (!this._mouseCaptured) { return; }
+
+            this._handleMouseButton(e, 0);
+            this._releaseMouse();
+        },
+
+        _handleMouseWheel: function (e) {
+            if (!this._focused) { return true; }
+
+            if (this._notify) {
+                this._notify(e);
+            }
+
+            var evt = (e ? e : window.event);
+            var pos = Util.getEventPosition(e, this._target, this._scale);
+            var wheelData = evt.detail ? evt.detail * -1 : evt.wheelDelta / 40;
+            var bmask;
+            if (wheelData > 0) {
+                bmask = 1 << 3;
+            } else {
+                bmask = 1 << 4;
+            }
+
+            if (this._onMouseButton) {
+                this._onMouseButton(pos.x, pos.y, 1, bmask);
+                this._onMouseButton(pos.x, pos.y, 0, bmask);
+            }
+            Util.stopEvent(e);
+            return false;
+        },
+
+        _handleMouseMove: function (e) {
+            if (! this._focused) { return true; }
+
+            if (this._notify) {
+                this._notify(e);
+            }
+
+            var evt = (e ? e : window.event);
+            var pos = Util.getEventPosition(e, this._target, this._scale);
+            if (this._onMouseMove) {
+                this._onMouseMove(pos.x, pos.y);
+            }
+            Util.stopEvent(e);
+            return false;
+        },
+
+        _handleMouseDisable: function (e) {
+            if (!this._focused) { return true; }
+
+            var evt = (e ? e : window.event);
+            var pos = Util.getEventPosition(e, this._target, this._scale);
+
+            /* Stop propagation if inside canvas area */
+            if ((pos.realx >= 0) && (pos.realy >= 0) &&
+                (pos.realx < this._target.offsetWidth) &&
+                (pos.realy < this._target.offsetHeight)) {
+                //Util.Debug("mouse event disabled");
+                Util.stopEvent(e);
+                return false;
+            }
+
+            return true;
+        },
+
+
+        // Public methods
+        grab: function () {
+            var c = this._target;
+
+            if ('ontouchstart' in document.documentElement) {
+                Util.addEvent(c, 'touchstart', this._eventHandlers.mousedown);
+                Util.addEvent(window, 'touchend', this._eventHandlers.mouseup);
+                Util.addEvent(c, 'touchend', this._eventHandlers.mouseup);
+                Util.addEvent(c, 'touchmove', this._eventHandlers.mousemove);
+            } else {
+                Util.addEvent(c, 'mousedown', this._eventHandlers.mousedown);
+                Util.addEvent(window, 'mouseup', this._eventHandlers.mouseup);
+                Util.addEvent(c, 'mouseup', this._eventHandlers.mouseup);
+                Util.addEvent(c, 'mousemove', this._eventHandlers.mousemove);
+                Util.addEvent(c, (Util.Engine.gecko) ? 'DOMMouseScroll' : 'mousewheel',
+                              this._eventHandlers.mousewheel);
+            }
+
+            /* Work around right and middle click browser behaviors */
+            Util.addEvent(document, 'click', this._eventHandlers.mousedisable);
+            Util.addEvent(document.body, 'contextmenu', this._eventHandlers.mousedisable);
+        },
+
+        ungrab: function () {
+            var c = this._target;
+
+            if ('ontouchstart' in document.documentElement) {
+                Util.removeEvent(c, 'touchstart', this._eventHandlers.mousedown);
+                Util.removeEvent(window, 'touchend', this._eventHandlers.mouseup);
+                Util.removeEvent(c, 'touchend', this._eventHandlers.mouseup);
+                Util.removeEvent(c, 'touchmove', this._eventHandlers.mousemove);
+            } else {
+                Util.removeEvent(c, 'mousedown', this._eventHandlers.mousedown);
+                Util.removeEvent(window, 'mouseup', this._eventHandlers.mouseup);
+                Util.removeEvent(c, 'mouseup', this._eventHandlers.mouseup);
+                Util.removeEvent(c, 'mousemove', this._eventHandlers.mousemove);
+                Util.removeEvent(c, (Util.Engine.gecko) ? 'DOMMouseScroll' : 'mousewheel',
+                                 this._eventHandlers.mousewheel);
+            }
+
+            /* Work around right and middle click browser behaviors */
+            Util.removeEvent(document, 'click', this._eventHandlers.mousedisable);
+            Util.removeEvent(document.body, 'contextmenu', this._eventHandlers.mousedisable);
+
+        }
+    };
+
+    Util.make_properties(Mouse, [
+        ['target',         'ro', 'dom'],   // DOM element that captures mouse input
+        ['notify',         'ro', 'func'],  // Function to call to notify whenever a mouse event is received
+        ['focused',        'rw', 'bool'],  // Capture and send mouse clicks/movement
+        ['scale',          'rw', 'float'], // Viewport scale factor 0.0 - 1.0
+
+        ['onMouseButton',  'rw', 'func'],  // Handler for mouse button click/release
+        ['onMouseMove',    'rw', 'func'],  // Handler for mouse movement
+        ['touchButton',    'rw', 'int']    // Button mask (1, 2, 4) for touch devices (0 means ignore clicks)
+    ]);
+})();

data/vendor/assets/javascripts/noVNC/jsunzip.js

@@ -0,0 +1,676 @@
+/*
+ * JSUnzip
+ *
+ * Copyright (c) 2011 by Erik Moller
+ * All Rights Reserved
+ *
+ * This software is provided 'as-is', without any express
+ * or implied warranty.  In no event will the authors be
+ * held liable for any damages arising from the use of
+ * this software.
+ *
+ * Permission is granted to anyone to use this software
+ * for any purpose, including commercial applications,
+ * and to alter it and redistribute it freely, subject to
+ * the following restrictions:
+ *
+ * 1. The origin of this software must not be
+ *    misrepresented; you must not claim that you
+ *    wrote the original software. If you use this
+ *    software in a product, an acknowledgment in
+ *    the product documentation would be appreciated
+ *    but is not required.
+ *
+ * 2. Altered source versions must be plainly marked
+ *    as such, and must not be misrepresented as
+ *    being the original software.
+ *
+ * 3. This notice may not be removed or altered from
+ *    any source distribution.
+ */
+ 
+var tinf;
+
+function JSUnzip() {
+
+    this.getInt = function(offset, size) {
+        switch (size) {
+        case 4:
+            return  (this.data.charCodeAt(offset + 3) & 0xff) << 24 | 
+                    (this.data.charCodeAt(offset + 2) & 0xff) << 16 | 
+                    (this.data.charCodeAt(offset + 1) & 0xff) << 8 | 
+                    (this.data.charCodeAt(offset + 0) & 0xff);
+            break;
+        case 2:
+            return  (this.data.charCodeAt(offset + 1) & 0xff) << 8 | 
+                    (this.data.charCodeAt(offset + 0) & 0xff);
+            break;
+        default:
+            return this.data.charCodeAt(offset) & 0xff;
+            break;
+        }
+    };
+
+    this.getDOSDate = function(dosdate, dostime) {
+        var day = dosdate & 0x1f;
+        var month = ((dosdate >> 5) & 0xf) - 1;
+        var year = 1980 + ((dosdate >> 9) & 0x7f)
+        var second = (dostime & 0x1f) * 2;
+        var minute = (dostime >> 5) & 0x3f;
+        hour = (dostime >> 11) & 0x1f;
+        return new Date(year, month, day, hour, minute, second);
+    }
+
+    this.open = function(data) {
+        this.data = data;
+        this.files = [];
+
+        if (this.data.length < 22)
+            return { 'status' : false, 'error' : 'Invalid data' };
+        var endOfCentralDirectory = this.data.length - 22;
+        while (endOfCentralDirectory >= 0 && this.getInt(endOfCentralDirectory, 4) != 0x06054b50)
+            --endOfCentralDirectory;
+        if (endOfCentralDirectory < 0)
+            return { 'status' : false, 'error' : 'Invalid data' };
+        if (this.getInt(endOfCentralDirectory + 4, 2) != 0 || this.getInt(endOfCentralDirectory + 6, 2) != 0)
+            return { 'status' : false, 'error' : 'No multidisk support' };
+
+        var entriesInThisDisk = this.getInt(endOfCentralDirectory + 8, 2);
+        var centralDirectoryOffset = this.getInt(endOfCentralDirectory + 16, 4);
+        var globalCommentLength = this.getInt(endOfCentralDirectory + 20, 2);
+        this.comment = this.data.slice(endOfCentralDirectory + 22, endOfCentralDirectory + 22 + globalCommentLength);
+
+        var fileOffset = centralDirectoryOffset;
+
+        for (var i = 0; i < entriesInThisDisk; ++i) {
+            if (this.getInt(fileOffset + 0, 4) != 0x02014b50)
+                return { 'status' : false, 'error' : 'Invalid data' };
+            if (this.getInt(fileOffset + 6, 2) > 20)
+                return { 'status' : false, 'error' : 'Unsupported version' };
+            if (this.getInt(fileOffset + 8, 2) & 1)
+                return { 'status' : false, 'error' : 'Encryption not implemented' };
+
+            var compressionMethod = this.getInt(fileOffset + 10, 2);
+            if (compressionMethod != 0 && compressionMethod != 8)
+                return { 'status' : false, 'error' : 'Unsupported compression method' };
+
+            var lastModFileTime = this.getInt(fileOffset + 12, 2);
+            var lastModFileDate = this.getInt(fileOffset + 14, 2);
+            var lastModifiedDate = this.getDOSDate(lastModFileDate, lastModFileTime);
+
+            var crc = this.getInt(fileOffset + 16, 4);
+            // TODO: crc
+
+            var compressedSize = this.getInt(fileOffset + 20, 4);
+            var uncompressedSize = this.getInt(fileOffset + 24, 4);
+
+            var fileNameLength = this.getInt(fileOffset + 28, 2);
+            var extraFieldLength = this.getInt(fileOffset + 30, 2);
+            var fileCommentLength = this.getInt(fileOffset + 32, 2);
+
+            var relativeOffsetOfLocalHeader = this.getInt(fileOffset + 42, 4);
+
+            var fileName = this.data.slice(fileOffset + 46, fileOffset + 46 + fileNameLength);
+            var fileComment = this.data.slice(fileOffset + 46 + fileNameLength + extraFieldLength, fileOffset + 46 + fileNameLength + extraFieldLength + fileCommentLength);
+
+            if (this.getInt(relativeOffsetOfLocalHeader + 0, 4) != 0x04034b50)
+                return { 'status' : false, 'error' : 'Invalid data' };
+            var localFileNameLength = this.getInt(relativeOffsetOfLocalHeader + 26, 2);
+            var localExtraFieldLength = this.getInt(relativeOffsetOfLocalHeader + 28, 2);
+            var localFileContent = relativeOffsetOfLocalHeader + 30 + localFileNameLength + localExtraFieldLength;
+
+            this.files[fileName] = 
+            {
+                'fileComment' : fileComment,
+                'compressionMethod' : compressionMethod,
+                'compressedSize' : compressedSize,
+                'uncompressedSize' : uncompressedSize,
+                'localFileContent' : localFileContent,
+                'lastModifiedDate' : lastModifiedDate
+            };
+
+            fileOffset += 46 + fileNameLength + extraFieldLength + fileCommentLength;
+        }
+        return { 'status' : true }
+    };     
+    
+
+    this.read = function(fileName) {
+        var fileInfo = this.files[fileName];
+        if (fileInfo) {
+            if (fileInfo.compressionMethod == 8) {
+                if (!tinf) {
+                    tinf = new TINF();
+                    tinf.init();
+                }
+                var result = tinf.uncompress(this.data, fileInfo.localFileContent);
+                if (result.status == tinf.OK)
+                    return { 'status' : true, 'data' : result.data };
+                else
+                    return { 'status' : false, 'error' : result.error };
+            } else {
+                return { 'status' : true, 'data' : this.data.slice(fileInfo.localFileContent, fileInfo.localFileContent + fileInfo.uncompressedSize) };
+            }
+        }
+        return { 'status' : false, 'error' : "File '" + fileName + "' doesn't exist in zip" };
+    };
+    
+};
+
+
+
+/*
+ * tinflate  -  tiny inflate
+ *
+ * Copyright (c) 2003 by Joergen Ibsen / Jibz
+ * All Rights Reserved
+ *
+ * http://www.ibsensoftware.com/
+ *
+ * This software is provided 'as-is', without any express
+ * or implied warranty.  In no event will the authors be
+ * held liable for any damages arising from the use of
+ * this software.
+ *
+ * Permission is granted to anyone to use this software
+ * for any purpose, including commercial applications,
+ * and to alter it and redistribute it freely, subject to
+ * the following restrictions:
+ *
+ * 1. The origin of this software must not be
+ *    misrepresented; you must not claim that you
+ *    wrote the original software. If you use this
+ *    software in a product, an acknowledgment in
+ *    the product documentation would be appreciated
+ *    but is not required.
+ *
+ * 2. Altered source versions must be plainly marked
+ *    as such, and must not be misrepresented as
+ *    being the original software.
+ *
+ * 3. This notice may not be removed or altered from
+ *    any source distribution.
+ */
+
+/*
+ * tinflate javascript port by Erik Moller in May 2011.
+ * emoller@opera.com
+ * 
+ * read_bits() patched by mike@imidio.com to allow
+ * reading more then 8 bits (needed in some zlib streams)
+ */
+
+"use strict";
+
+function TINF() {
+    
+this.OK = 0;
+this.DATA_ERROR = (-3);
+this.WINDOW_SIZE = 32768;
+
+/* ------------------------------ *
+ * -- internal data structures -- *
+ * ------------------------------ */
+
+this.TREE = function() {
+   this.table = new Array(16);  /* table of code length counts */
+   this.trans = new Array(288); /* code -> symbol translation table */
+};
+
+this.DATA = function(that) {
+   this.source = '';
+   this.sourceIndex = 0;
+   this.tag = 0;
+   this.bitcount = 0;
+
+   this.dest = [];
+   
+   this.history = [];
+
+   this.ltree = new that.TREE(); /* dynamic length/symbol tree */
+   this.dtree = new that.TREE(); /* dynamic distance tree */
+};
+
+/* --------------------------------------------------- *
+ * -- uninitialized global data (static structures) -- *
+ * --------------------------------------------------- */
+
+this.sltree = new this.TREE(); /* fixed length/symbol tree */
+this.sdtree = new this.TREE(); /* fixed distance tree */
+
+/* extra bits and base tables for length codes */
+this.length_bits = new Array(30);
+this.length_base = new Array(30);
+
+/* extra bits and base tables for distance codes */
+this.dist_bits = new Array(30);
+this.dist_base = new Array(30);
+
+/* special ordering of code length codes */
+this.clcidx = [
+   16, 17, 18, 0, 8, 7, 9, 6,
+   10, 5, 11, 4, 12, 3, 13, 2,
+   14, 1, 15
+];
+
+/* ----------------------- *
+ * -- utility functions -- *
+ * ----------------------- */
+
+/* build extra bits and base tables */
+this.build_bits_base = function(bits, base, delta, first)
+{
+   var i, sum;
+
+   /* build bits table */
+   for (i = 0; i < delta; ++i) bits[i] = 0;
+   for (i = 0; i < 30 - delta; ++i) bits[i + delta] = Math.floor(i / delta);
+
+   /* build base table */
+   for (sum = first, i = 0; i < 30; ++i)
+   {
+      base[i] = sum;
+      sum += 1 << bits[i];
+   }
+}
+
+/* build the fixed huffman trees */
+this.build_fixed_trees = function(lt, dt)
+{
+   var i;
+
+   /* build fixed length tree */
+   for (i = 0; i < 7; ++i) lt.table[i] = 0;
+
+   lt.table[7] = 24;
+   lt.table[8] = 152;
+   lt.table[9] = 112;
+
+   for (i = 0; i < 24; ++i) lt.trans[i] = 256 + i;
+   for (i = 0; i < 144; ++i) lt.trans[24 + i] = i;
+   for (i = 0; i < 8; ++i) lt.trans[24 + 144 + i] = 280 + i;
+   for (i = 0; i < 112; ++i) lt.trans[24 + 144 + 8 + i] = 144 + i;
+
+   /* build fixed distance tree */
+   for (i = 0; i < 5; ++i) dt.table[i] = 0;
+
+   dt.table[5] = 32;
+
+   for (i = 0; i < 32; ++i) dt.trans[i] = i;
+}
+
+/* given an array of code lengths, build a tree */
+this.build_tree = function(t, lengths, loffset, num)
+{
+   var offs = new Array(16);
+   var i, sum;
+
+   /* clear code length count table */
+   for (i = 0; i < 16; ++i) t.table[i] = 0;
+
+   /* scan symbol lengths, and sum code length counts */
+   for (i = 0; i < num; ++i) t.table[lengths[loffset + i]]++;
+
+   t.table[0] = 0;
+
+   /* compute offset table for distribution sort */
+   for (sum = 0, i = 0; i < 16; ++i)
+   {
+      offs[i] = sum;
+      sum += t.table[i];
+   }
+
+   /* create code->symbol translation table (symbols sorted by code) */
+   for (i = 0; i < num; ++i)
+   {
+      if (lengths[loffset + i]) t.trans[offs[lengths[loffset + i]]++] = i;
+   }
+}
+
+/* ---------------------- *
+ * -- decode functions -- *
+ * ---------------------- */
+
+/* get one bit from source stream */
+this.getbit = function(d)
+{
+   var bit;
+
+   /* check if tag is empty */
+   if (!d.bitcount--)
+   {
+      /* load next tag */
+      d.tag = d.source[d.sourceIndex++] & 0xff;
+      d.bitcount = 7;
+   }
+
+   /* shift bit out of tag */
+   bit = d.tag & 0x01;
+   d.tag >>= 1;
+
+   return bit;
+}
+
+/* read a num bit value from a stream and add base */
+function read_bits_direct(source, bitcount, tag, idx, num)
+{
+    var val = 0;
+    while (bitcount < 24) {
+        tag = tag | (source[idx++] & 0xff) << bitcount;
+        bitcount += 8;
+    }
+    val = tag & (0xffff >> (16 - num));
+    tag >>= num;
+    bitcount -= num;
+    return [bitcount, tag, idx, val];
+}
+this.read_bits = function(d, num, base)
+{
+    if (!num)
+        return base;
+
+    var ret = read_bits_direct(d.source, d.bitcount, d.tag, d.sourceIndex, num);
+    d.bitcount = ret[0];
+    d.tag = ret[1];
+    d.sourceIndex = ret[2];
+    return ret[3] + base;
+}
+
+/* given a data stream and a tree, decode a symbol */
+this.decode_symbol = function(d, t)
+{
+    while (d.bitcount < 16) {
+        d.tag = d.tag | (d.source[d.sourceIndex++] & 0xff) << d.bitcount;
+        d.bitcount += 8;
+    }
+    
+    var sum = 0, cur = 0, len = 0;
+    do {
+        cur = 2 * cur + ((d.tag & (1 << len)) >> len);
+
+        ++len;
+
+        sum += t.table[len];
+        cur -= t.table[len];
+
+    } while (cur >= 0);
+
+    d.tag >>= len;
+    d.bitcount -= len;
+
+    return t.trans[sum + cur];
+}
+
+/* given a data stream, decode dynamic trees from it */
+this.decode_trees = function(d, lt, dt)
+{
+   var code_tree = new this.TREE();
+   var lengths = new Array(288+32);
+   var hlit, hdist, hclen;
+   var i, num, length;
+
+   /* get 5 bits HLIT (257-286) */
+   hlit = this.read_bits(d, 5, 257);
+
+   /* get 5 bits HDIST (1-32) */
+   hdist = this.read_bits(d, 5, 1);
+
+   /* get 4 bits HCLEN (4-19) */
+   hclen = this.read_bits(d, 4, 4);
+
+   for (i = 0; i < 19; ++i) lengths[i] = 0;
+
+   /* read code lengths for code length alphabet */
+   for (i = 0; i < hclen; ++i)
+   {
+      /* get 3 bits code length (0-7) */
+      var clen = this.read_bits(d, 3, 0);
+
+      lengths[this.clcidx[i]] = clen;
+   }
+
+   /* build code length tree */
+   this.build_tree(code_tree, lengths, 0, 19);
+
+   /* decode code lengths for the dynamic trees */
+   for (num = 0; num < hlit + hdist; )
+   {
+      var sym = this.decode_symbol(d, code_tree);
+
+      switch (sym)
+      {
+      case 16:
+         /* copy previous code length 3-6 times (read 2 bits) */
+         {
+            var prev = lengths[num - 1];
+            for (length = this.read_bits(d, 2, 3); length; --length)
+            {
+               lengths[num++] = prev;
+            }
+         }
+         break;
+      case 17:
+         /* repeat code length 0 for 3-10 times (read 3 bits) */
+         for (length = this.read_bits(d, 3, 3); length; --length)
+         {
+            lengths[num++] = 0;
+         }
+         break;
+      case 18:
+         /* repeat code length 0 for 11-138 times (read 7 bits) */
+         for (length = this.read_bits(d, 7, 11); length; --length)
+         {
+            lengths[num++] = 0;
+         }
+         break;
+      default:
+         /* values 0-15 represent the actual code lengths */
+         lengths[num++] = sym;
+         break;
+      }
+   }
+
+   /* build dynamic trees */
+   this.build_tree(lt, lengths, 0, hlit);
+   this.build_tree(dt, lengths, hlit, hdist);
+}
+
+/* ----------------------------- *
+ * -- block inflate functions -- *
+ * ----------------------------- */
+
+/* given a stream and two trees, inflate a block of data */
+this.inflate_block_data = function(d, lt, dt)
+{
+   // js optimization.
+   var ddest = d.dest;
+   var ddestlength = ddest.length;
+
+   while (1)
+   {
+      var sym = this.decode_symbol(d, lt);
+
+      /* check for end of block */
+      if (sym == 256)
+      {
+         return this.OK;
+      }
+
+      if (sym < 256)
+      {
+         ddest[ddestlength++] = sym; // ? String.fromCharCode(sym);
+         d.history.push(sym);
+      } else {
+
+         var length, dist, offs;
+         var i;
+
+         sym -= 257;
+
+         /* possibly get more bits from length code */
+         length = this.read_bits(d, this.length_bits[sym], this.length_base[sym]);
+
+         dist = this.decode_symbol(d, dt);
+
+         /* possibly get more bits from distance code */
+         offs = d.history.length - this.read_bits(d, this.dist_bits[dist], this.dist_base[dist]);
+
+         if (offs < 0)
+             throw ("Invalid zlib offset " + offs);
+         
+         /* copy match */
+         for (i = offs; i < offs + length; ++i) {
+            //ddest[ddestlength++] = ddest[i];
+            ddest[ddestlength++] = d.history[i];
+            d.history.push(d.history[i]);
+         }
+      }
+   }
+}
+
+/* inflate an uncompressed block of data */
+this.inflate_uncompressed_block = function(d)
+{
+   var length, invlength;
+   var i;
+
+   if (d.bitcount > 7) {
+       var overflow = Math.floor(d.bitcount / 8);
+       d.sourceIndex -= overflow;
+       d.bitcount = 0;
+       d.tag = 0;
+   }
+   
+   /* get length */
+   length = d.source[d.sourceIndex+1];
+   length = 256*length + d.source[d.sourceIndex];
+
+   /* get one's complement of length */
+   invlength = d.source[d.sourceIndex+3];
+   invlength = 256*invlength + d.source[d.sourceIndex+2];
+
+   /* check length */
+   if (length != (~invlength & 0x0000ffff)) return this.DATA_ERROR;
+
+   d.sourceIndex += 4;
+
+   /* copy block */
+   for (i = length; i; --i) {
+       d.history.push(d.source[d.sourceIndex]);
+       d.dest[d.dest.length] = d.source[d.sourceIndex++];
+   }
+
+   /* make sure we start next block on a byte boundary */
+   d.bitcount = 0;
+
+   return this.OK;
+}
+
+/* inflate a block of data compressed with fixed huffman trees */
+this.inflate_fixed_block = function(d)
+{
+   /* decode block using fixed trees */
+   return this.inflate_block_data(d, this.sltree, this.sdtree);
+}
+
+/* inflate a block of data compressed with dynamic huffman trees */
+this.inflate_dynamic_block = function(d)
+{
+   /* decode trees from stream */
+   this.decode_trees(d, d.ltree, d.dtree);
+
+   /* decode block using decoded trees */
+   return this.inflate_block_data(d, d.ltree, d.dtree);
+}
+
+/* ---------------------- *
+ * -- public functions -- *
+ * ---------------------- */
+
+/* initialize global (static) data */
+this.init = function()
+{
+   /* build fixed huffman trees */
+   this.build_fixed_trees(this.sltree, this.sdtree);
+
+   /* build extra bits and base tables */
+   this.build_bits_base(this.length_bits, this.length_base, 4, 3);
+   this.build_bits_base(this.dist_bits, this.dist_base, 2, 1);
+
+   /* fix a special case */
+   this.length_bits[28] = 0;
+   this.length_base[28] = 258;
+
+   this.reset();   
+}
+
+this.reset = function()
+{
+   this.d = new this.DATA(this);
+   delete this.header;
+}
+
+/* inflate stream from source to dest */
+this.uncompress = function(source, offset)
+{
+
+   var d = this.d;
+   var bfinal;
+
+   /* initialise data */
+   d.source = source;
+   d.sourceIndex = offset;
+   d.bitcount = 0;
+
+   d.dest = [];
+
+   // Skip zlib header at start of stream
+   if (typeof this.header == 'undefined') {
+       this.header = this.read_bits(d, 16, 0);
+       /* byte 0: 0x78, 7 = 32k window size, 8 = deflate */
+       /* byte 1: check bits for header and other flags */
+   }
+
+   var blocks = 0;
+   
+   do {
+
+      var btype;
+      var res;
+
+      /* read final block flag */
+      bfinal = this.getbit(d);
+
+      /* read block type (2 bits) */
+      btype = this.read_bits(d, 2, 0);
+
+      /* decompress block */
+      switch (btype)
+      {
+      case 0:
+         /* decompress uncompressed block */
+         res = this.inflate_uncompressed_block(d);
+         break;
+      case 1:
+         /* decompress block with fixed huffman trees */
+         res = this.inflate_fixed_block(d);
+         break;
+      case 2:
+         /* decompress block with dynamic huffman trees */
+         res = this.inflate_dynamic_block(d);
+         break;
+      default:
+         return { 'status' : this.DATA_ERROR };
+      }
+
+      if (res != this.OK) return { 'status' : this.DATA_ERROR };
+      blocks++;
+      
+   } while (!bfinal && d.sourceIndex < d.source.length);
+
+   d.history = d.history.slice(-this.WINDOW_SIZE);
+   
+   return { 'status' : this.OK, 'data' : d.dest };
+}
+
+};