@novnc/novnc 1.3.0-beta → 1.3.0-g6710410

package/README.md

@@ -113,8 +113,13 @@ proxy.
   used to specify the location of a running VNC server:
 
     `./utils/novnc_proxy --vnc localhost:5901`
+    
+* If you don't need to expose the web server to public internet, you can
+  bind to localhost:
+  
+    `./utils/novnc_proxy --vnc localhost:5901 --listen localhost:6081`
 
-* Point your browser to the cut-and-paste URL that is output by the `novnc_procy`
+* Point your browser to the cut-and-paste URL that is output by the `novnc_proxy`
   script. Hit the Connect button, enter a password if the VNC server has one
   configured, and enjoy!
 

package/core/decoders/jpeg.js

@@ -0,0 +1,141 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2019 The noVNC Authors
+ * Licensed under MPL 2.0 (see LICENSE.txt)
+ *
+ * See README.md for usage and integration instructions.
+ *
+ */
+
+export default class JPEGDecoder {
+    constructor() {
+        // RealVNC will reuse the quantization tables
+        // and Huffman tables, so we need to cache them.
+        this._quantTables = [];
+        this._huffmanTables = [];
+        this._cachedQuantTables = [];
+        this._cachedHuffmanTables = [];
+
+        this._jpegLength = 0;
+        this._segments = [];
+    }
+
+    decodeRect(x, y, width, height, sock, display, depth) {
+        // A rect of JPEG encodings is simply a JPEG file
+        if (!this._parseJPEG(sock.rQslice(0))) {
+            return false;
+        }
+        const data = sock.rQshiftBytes(this._jpegLength);
+        if (this._quantTables.length != 0 && this._huffmanTables.length != 0) {
+            // If there are quantization tables and Huffman tables in the JPEG
+            // image, we can directly render it.
+            display.imageRect(x, y, width, height, "image/jpeg", data);
+            return true;
+        } else {
+            // Otherwise we need to insert cached tables.
+            const sofIndex = this._segments.findIndex(
+                x => x[1] == 0xC0 || x[1] == 0xC2
+            );
+            if (sofIndex == -1) {
+                throw new Error("Illegal JPEG image without SOF");
+            }
+            let segments = this._segments.slice(0, sofIndex);
+            segments = segments.concat(this._quantTables.length ?
+                this._quantTables :
+                this._cachedQuantTables);
+            segments.push(this._segments[sofIndex]);
+            segments = segments.concat(this._huffmanTables.length ?
+                this._huffmanTables :
+                this._cachedHuffmanTables,
+                                       this._segments.slice(sofIndex + 1));
+            let length = 0;
+            for (let i = 0; i < segments.length; i++) {
+                length += segments[i].length;
+            }
+            const data = new Uint8Array(length);
+            length = 0;
+            for (let i = 0; i < segments.length; i++) {
+                data.set(segments[i], length);
+                length += segments[i].length;
+            }
+            display.imageRect(x, y, width, height, "image/jpeg", data);
+            return true;
+        }
+    }
+
+    _parseJPEG(buffer) {
+        if (this._quantTables.length != 0) {
+            this._cachedQuantTables = this._quantTables;
+        }
+        if (this._huffmanTables.length != 0) {
+            this._cachedHuffmanTables = this._huffmanTables;
+        }
+        this._quantTables = [];
+        this._huffmanTables = [];
+        this._segments = [];
+        let i = 0;
+        let bufferLength = buffer.length;
+        while (true) {
+            let j = i;
+            if (j + 2 > bufferLength) {
+                return false;
+            }
+            if (buffer[j] != 0xFF) {
+                throw new Error("Illegal JPEG marker received (byte: " +
+                                   buffer[j] + ")");
+            }
+            const type = buffer[j+1];
+            j += 2;
+            if (type == 0xD9) {
+                this._jpegLength = j;
+                this._segments.push(buffer.slice(i, j));
+                return true;
+            } else if (type == 0xDA) {
+                // start of scan
+                let hasFoundEndOfScan = false;
+                for (let k = j + 3; k + 1 < bufferLength; k++) {
+                    if (buffer[k] == 0xFF && buffer[k+1] != 0x00 &&
+                        !(buffer[k+1] >= 0xD0 && buffer[k+1] <= 0xD7)) {
+                        j = k;
+                        hasFoundEndOfScan = true;
+                        break;
+                    }
+                }
+                if (!hasFoundEndOfScan) {
+                    return false;
+                }
+                this._segments.push(buffer.slice(i, j));
+                i = j;
+                continue;
+            } else if (type >= 0xD0 && type < 0xD9 || type == 0x01) {
+                // No length after marker
+                this._segments.push(buffer.slice(i, j));
+                i = j;
+                continue;
+            }
+            if (j + 2 > bufferLength) {
+                return false;
+            }
+            const length = (buffer[j] << 8) + buffer[j+1] - 2;
+            if (length < 0) {
+                throw new Error("Illegal JPEG length received (length: " +
+                                   length + ")");
+            }
+            j += 2;
+            if (j + length > bufferLength) {
+                return false;
+            }
+            j += length;
+            const segment = buffer.slice(i, j);
+            if (type == 0xC4) {
+                // Huffman tables
+                this._huffmanTables.push(segment);
+            } else if (type == 0xDB) {
+                // Quantization tables
+                this._quantTables.push(segment);
+            }
+            this._segments.push(segment);
+            i = j;
+        }
+    }
+}

package/core/decoders/zrle.js

@@ -0,0 +1,185 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2021 The noVNC Authors
+ * Licensed under MPL 2.0 (see LICENSE.txt)
+ *
+ * See README.md for usage and integration instructions.
+ *
+ */
+
+import Inflate from "../inflator.js";
+
+const ZRLE_TILE_WIDTH = 64;
+const ZRLE_TILE_HEIGHT = 64;
+
+export default class ZRLEDecoder {
+    constructor() {
+        this._length = 0;
+        this._inflator = new Inflate();
+
+        this._pixelBuffer = new Uint8Array(ZRLE_TILE_WIDTH * ZRLE_TILE_HEIGHT * 4);
+        this._tileBuffer = new Uint8Array(ZRLE_TILE_WIDTH * ZRLE_TILE_HEIGHT * 4);
+    }
+
+    decodeRect(x, y, width, height, sock, display, depth) {
+        if (this._length === 0) {
+            if (sock.rQwait("ZLib data length", 4)) {
+                return false;
+            }
+            this._length = sock.rQshift32();
+        }
+        if (sock.rQwait("Zlib data", this._length)) {
+            return false;
+        }
+
+        const data = sock.rQshiftBytes(this._length);
+
+        this._inflator.setInput(data);
+
+        for (let ty = y; ty < y + height; ty += ZRLE_TILE_HEIGHT) {
+            let th = Math.min(ZRLE_TILE_HEIGHT, y + height - ty);
+
+            for (let tx = x; tx < x + width; tx += ZRLE_TILE_WIDTH) {
+                let tw = Math.min(ZRLE_TILE_WIDTH, x + width - tx);
+
+                const tileSize = tw * th;
+                const subencoding = this._inflator.inflate(1)[0];
+                if (subencoding === 0) {
+                    // raw data
+                    const data = this._readPixels(tileSize);
+                    display.blitImage(tx, ty, tw, th, data, 0, false);
+                } else if (subencoding === 1) {
+                    // solid
+                    const background = this._readPixels(1);
+                    display.fillRect(tx, ty, tw, th, [background[0], background[1], background[2]]);
+                } else if (subencoding >= 2 && subencoding <= 16) {
+                    const data = this._decodePaletteTile(subencoding, tileSize, tw, th);
+                    display.blitImage(tx, ty, tw, th, data, 0, false);
+                } else if (subencoding === 128) {
+                    const data = this._decodeRLETile(tileSize);
+                    display.blitImage(tx, ty, tw, th, data, 0, false);
+                } else if (subencoding >= 130 && subencoding <= 255) {
+                    const data = this._decodeRLEPaletteTile(subencoding - 128, tileSize);
+                    display.blitImage(tx, ty, tw, th, data, 0, false);
+                } else {
+                    throw new Error('Unknown subencoding: ' + subencoding);
+                }
+            }
+        }
+        this._length = 0;
+        return true;
+    }
+
+    _getBitsPerPixelInPalette(paletteSize) {
+        if (paletteSize <= 2) {
+            return 1;
+        } else if (paletteSize <= 4) {
+            return 2;
+        } else if (paletteSize <= 16) {
+            return 4;
+        }
+    }
+
+    _readPixels(pixels) {
+        let data = this._pixelBuffer;
+        const buffer = this._inflator.inflate(3*pixels);
+        for (let i = 0, j = 0; i < pixels*4; i += 4, j += 3) {
+            data[i]     = buffer[j];
+            data[i + 1] = buffer[j + 1];
+            data[i + 2] = buffer[j + 2];
+            data[i + 3] = 255;  // Add the Alpha
+        }
+        return data;
+    }
+
+    _decodePaletteTile(paletteSize, tileSize, tilew, tileh) {
+        const data = this._tileBuffer;
+        const palette = this._readPixels(paletteSize);
+        const bitsPerPixel = this._getBitsPerPixelInPalette(paletteSize);
+        const mask = (1 << bitsPerPixel) - 1;
+
+        let offset = 0;
+        let encoded = this._inflator.inflate(1)[0];
+
+        for (let y=0; y<tileh; y++) {
+            let shift = 8-bitsPerPixel;
+            for (let x=0; x<tilew; x++) {
+                if (shift<0) {
+                    shift=8-bitsPerPixel;
+                    encoded = this._inflator.inflate(1)[0];
+                }
+                let indexInPalette = (encoded>>shift) & mask;
+
+                data[offset] = palette[indexInPalette * 4];
+                data[offset + 1] = palette[indexInPalette * 4 + 1];
+                data[offset + 2] = palette[indexInPalette * 4 + 2];
+                data[offset + 3] = palette[indexInPalette * 4 + 3];
+                offset += 4;
+                shift-=bitsPerPixel;
+            }
+            if (shift<8-bitsPerPixel && y<tileh-1) {
+                encoded =  this._inflator.inflate(1)[0];
+            }
+        }
+        return data;
+    }
+
+    _decodeRLETile(tileSize) {
+        const data = this._tileBuffer;
+        let i = 0;
+        while (i < tileSize) {
+            const pixel = this._readPixels(1);
+            const length = this._readRLELength();
+            for (let j = 0; j < length; j++) {
+                data[i * 4] = pixel[0];
+                data[i * 4 + 1] = pixel[1];
+                data[i * 4 + 2] = pixel[2];
+                data[i * 4 + 3] = pixel[3];
+                i++;
+            }
+        }
+        return data;
+    }
+
+    _decodeRLEPaletteTile(paletteSize, tileSize) {
+        const data = this._tileBuffer;
+
+        // palette
+        const palette = this._readPixels(paletteSize);
+
+        let offset = 0;
+        while (offset < tileSize) {
+            let indexInPalette = this._inflator.inflate(1)[0];
+            let length = 1;
+            if (indexInPalette >= 128) {
+                indexInPalette -= 128;
+                length = this._readRLELength();
+            }
+            if (indexInPalette > paletteSize) {
+                throw new Error('Too big index in palette: ' + indexInPalette + ', palette size: ' + paletteSize);
+            }
+            if (offset + length > tileSize) {
+                throw new Error('Too big rle length in palette mode: ' + length + ', allowed length is: ' + (tileSize - offset));
+            }
+
+            for (let j = 0; j < length; j++) {
+                data[offset * 4] = palette[indexInPalette * 4];
+                data[offset * 4 + 1] = palette[indexInPalette * 4 + 1];
+                data[offset * 4 + 2] = palette[indexInPalette * 4 + 2];
+                data[offset * 4 + 3] = palette[indexInPalette * 4 + 3];
+                offset++;
+            }
+        }
+        return data;
+    }
+
+    _readRLELength() {
+        let length = 0;
+        let current = 0;
+        do {
+            current = this._inflator.inflate(1)[0];
+            length += current;
+        } while (current === 255);
+        return length + 1;
+    }
+}

package/core/encodings.js

@@ -12,7 +12,9 @@ export const encodings = {
     encodingRRE: 2,
     encodingHextile: 5,
     encodingTight: 7,
+    encodingZRLE: 16,
     encodingTightPNG: -260,
+    encodingJPEG: 21,
 
     pseudoEncodingQualityLevel9: -23,
     pseudoEncodingQualityLevel0: -32,
@@ -38,7 +40,9 @@ export function encodingName(num) {
         case encodings.encodingRRE:      return "RRE";
         case encodings.encodingHextile:  return "Hextile";
         case encodings.encodingTight:    return "Tight";
+        case encodings.encodingZRLE:     return "ZRLE";
         case encodings.encodingTightPNG: return "TightPNG";
+        case encodings.encodingJPEG:     return "JPEG";
         default:                         return "[unknown encoding " + num + "]";
     }
 }

package/core/rfb.js

@@ -32,6 +32,8 @@ import RREDecoder from "./decoders/rre.js";
 import HextileDecoder from "./decoders/hextile.js";
 import TightDecoder from "./decoders/tight.js";
 import TightPNGDecoder from "./decoders/tightpng.js";
+import ZRLEDecoder from "./decoders/zrle.js";
+import JPEGDecoder from "./decoders/jpeg.js";
 
 // How many seconds to wait for a disconnect to finish
 const DISCONNECT_TIMEOUT = 3;
@@ -218,6 +220,8 @@ export default class RFB extends EventTargetMixin {
         this._decoders[encodings.encodingHextile] = new HextileDecoder();
         this._decoders[encodings.encodingTight] = new TightDecoder();
         this._decoders[encodings.encodingTightPNG] = new TightPNGDecoder();
+        this._decoders[encodings.encodingZRLE] = new ZRLEDecoder();
+        this._decoders[encodings.encodingJPEG] = new JPEGDecoder();
 
         // NB: nothing that needs explicit teardown should be done
         // before this point, since this can throw an exception
@@ -432,8 +436,8 @@ export default class RFB extends EventTargetMixin {
         }
     }
 
-    focus() {
-        this._canvas.focus();
+    focus(options) {
+        this._canvas.focus(options);
     }
 
     blur() {
@@ -609,7 +613,7 @@ export default class RFB extends EventTargetMixin {
             return;
         }
 
-        this.focus();
+        this.focus({ preventScroll: true });
     }
 
     _setDesktopName(name) {
@@ -1772,6 +1776,8 @@ export default class RFB extends EventTargetMixin {
         if (this._fbDepth == 24) {
             encs.push(encodings.encodingTight);
             encs.push(encodings.encodingTightPNG);
+            encs.push(encodings.encodingZRLE);
+            encs.push(encodings.encodingJPEG);
             encs.push(encodings.encodingHextile);
             encs.push(encodings.encodingRRE);
         }

package/docs/API.md

@@ -328,7 +328,14 @@ Keyboard events will be sent to the remote server after this point.
 
 ##### Syntax
 
-    RFB.focus( );
+    RFB.focus( [options] );
+
+###### Parameters
+
+**`options`** *Optional*
+  - A `object` providing options to control how the focus will be
+    performed. Please see [`HTMLElement.focus()`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus)
+    for available options.
 
 #### RFB.blur()
 

package/lib/decoders/jpeg.js

@@ -0,0 +1,188 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2019 The noVNC Authors
+ * Licensed under MPL 2.0 (see LICENSE.txt)
+ *
+ * See README.md for usage and integration instructions.
+ *
+ */
+var JPEGDecoder = /*#__PURE__*/function () {
+  function JPEGDecoder() {
+    _classCallCheck(this, JPEGDecoder);
+
+    // RealVNC will reuse the quantization tables
+    // and Huffman tables, so we need to cache them.
+    this._quantTables = [];
+    this._huffmanTables = [];
+    this._cachedQuantTables = [];
+    this._cachedHuffmanTables = [];
+    this._jpegLength = 0;
+    this._segments = [];
+  }
+
+  _createClass(JPEGDecoder, [{
+    key: "decodeRect",
+    value: function decodeRect(x, y, width, height, sock, display, depth) {
+      // A rect of JPEG encodings is simply a JPEG file
+      if (!this._parseJPEG(sock.rQslice(0))) {
+        return false;
+      }
+
+      var data = sock.rQshiftBytes(this._jpegLength);
+
+      if (this._quantTables.length != 0 && this._huffmanTables.length != 0) {
+        // If there are quantization tables and Huffman tables in the JPEG
+        // image, we can directly render it.
+        display.imageRect(x, y, width, height, "image/jpeg", data);
+        return true;
+      } else {
+        // Otherwise we need to insert cached tables.
+        var sofIndex = this._segments.findIndex(function (x) {
+          return x[1] == 0xC0 || x[1] == 0xC2;
+        });
+
+        if (sofIndex == -1) {
+          throw new Error("Illegal JPEG image without SOF");
+        }
+
+        var segments = this._segments.slice(0, sofIndex);
+
+        segments = segments.concat(this._quantTables.length ? this._quantTables : this._cachedQuantTables);
+        segments.push(this._segments[sofIndex]);
+        segments = segments.concat(this._huffmanTables.length ? this._huffmanTables : this._cachedHuffmanTables, this._segments.slice(sofIndex + 1));
+        var length = 0;
+
+        for (var i = 0; i < segments.length; i++) {
+          length += segments[i].length;
+        }
+
+        var _data = new Uint8Array(length);
+
+        length = 0;
+
+        for (var _i = 0; _i < segments.length; _i++) {
+          _data.set(segments[_i], length);
+
+          length += segments[_i].length;
+        }
+
+        display.imageRect(x, y, width, height, "image/jpeg", _data);
+        return true;
+      }
+    }
+  }, {
+    key: "_parseJPEG",
+    value: function _parseJPEG(buffer) {
+      if (this._quantTables.length != 0) {
+        this._cachedQuantTables = this._quantTables;
+      }
+
+      if (this._huffmanTables.length != 0) {
+        this._cachedHuffmanTables = this._huffmanTables;
+      }
+
+      this._quantTables = [];
+      this._huffmanTables = [];
+      this._segments = [];
+      var i = 0;
+      var bufferLength = buffer.length;
+
+      while (true) {
+        var j = i;
+
+        if (j + 2 > bufferLength) {
+          return false;
+        }
+
+        if (buffer[j] != 0xFF) {
+          throw new Error("Illegal JPEG marker received (byte: " + buffer[j] + ")");
+        }
+
+        var type = buffer[j + 1];
+        j += 2;
+
+        if (type == 0xD9) {
+          this._jpegLength = j;
+
+          this._segments.push(buffer.slice(i, j));
+
+          return true;
+        } else if (type == 0xDA) {
+          // start of scan
+          var hasFoundEndOfScan = false;
+
+          for (var k = j + 3; k + 1 < bufferLength; k++) {
+            if (buffer[k] == 0xFF && buffer[k + 1] != 0x00 && !(buffer[k + 1] >= 0xD0 && buffer[k + 1] <= 0xD7)) {
+              j = k;
+              hasFoundEndOfScan = true;
+              break;
+            }
+          }
+
+          if (!hasFoundEndOfScan) {
+            return false;
+          }
+
+          this._segments.push(buffer.slice(i, j));
+
+          i = j;
+          continue;
+        } else if (type >= 0xD0 && type < 0xD9 || type == 0x01) {
+          // No length after marker
+          this._segments.push(buffer.slice(i, j));
+
+          i = j;
+          continue;
+        }
+
+        if (j + 2 > bufferLength) {
+          return false;
+        }
+
+        var length = (buffer[j] << 8) + buffer[j + 1] - 2;
+
+        if (length < 0) {
+          throw new Error("Illegal JPEG length received (length: " + length + ")");
+        }
+
+        j += 2;
+
+        if (j + length > bufferLength) {
+          return false;
+        }
+
+        j += length;
+        var segment = buffer.slice(i, j);
+
+        if (type == 0xC4) {
+          // Huffman tables
+          this._huffmanTables.push(segment);
+        } else if (type == 0xDB) {
+          // Quantization tables
+          this._quantTables.push(segment);
+        }
+
+        this._segments.push(segment);
+
+        i = j;
+      }
+    }
+  }]);
+
+  return JPEGDecoder;
+}();
+
+exports["default"] = JPEGDecoder;

package/lib/decoders/zrle.js

@@ -0,0 +1,234 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _inflator = _interopRequireDefault(require("../inflator.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var ZRLE_TILE_WIDTH = 64;
+var ZRLE_TILE_HEIGHT = 64;
+
+var ZRLEDecoder = /*#__PURE__*/function () {
+  function ZRLEDecoder() {
+    _classCallCheck(this, ZRLEDecoder);
+
+    this._length = 0;
+    this._inflator = new _inflator["default"]();
+    this._pixelBuffer = new Uint8Array(ZRLE_TILE_WIDTH * ZRLE_TILE_HEIGHT * 4);
+    this._tileBuffer = new Uint8Array(ZRLE_TILE_WIDTH * ZRLE_TILE_HEIGHT * 4);
+  }
+
+  _createClass(ZRLEDecoder, [{
+    key: "decodeRect",
+    value: function decodeRect(x, y, width, height, sock, display, depth) {
+      if (this._length === 0) {
+        if (sock.rQwait("ZLib data length", 4)) {
+          return false;
+        }
+
+        this._length = sock.rQshift32();
+      }
+
+      if (sock.rQwait("Zlib data", this._length)) {
+        return false;
+      }
+
+      var data = sock.rQshiftBytes(this._length);
+
+      this._inflator.setInput(data);
+
+      for (var ty = y; ty < y + height; ty += ZRLE_TILE_HEIGHT) {
+        var th = Math.min(ZRLE_TILE_HEIGHT, y + height - ty);
+
+        for (var tx = x; tx < x + width; tx += ZRLE_TILE_WIDTH) {
+          var tw = Math.min(ZRLE_TILE_WIDTH, x + width - tx);
+          var tileSize = tw * th;
+
+          var subencoding = this._inflator.inflate(1)[0];
+
+          if (subencoding === 0) {
+            // raw data
+            var _data = this._readPixels(tileSize);
+
+            display.blitImage(tx, ty, tw, th, _data, 0, false);
+          } else if (subencoding === 1) {
+            // solid
+            var background = this._readPixels(1);
+
+            display.fillRect(tx, ty, tw, th, [background[0], background[1], background[2]]);
+          } else if (subencoding >= 2 && subencoding <= 16) {
+            var _data2 = this._decodePaletteTile(subencoding, tileSize, tw, th);
+
+            display.blitImage(tx, ty, tw, th, _data2, 0, false);
+          } else if (subencoding === 128) {
+            var _data3 = this._decodeRLETile(tileSize);
+
+            display.blitImage(tx, ty, tw, th, _data3, 0, false);
+          } else if (subencoding >= 130 && subencoding <= 255) {
+            var _data4 = this._decodeRLEPaletteTile(subencoding - 128, tileSize);
+
+            display.blitImage(tx, ty, tw, th, _data4, 0, false);
+          } else {
+            throw new Error('Unknown subencoding: ' + subencoding);
+          }
+        }
+      }
+
+      this._length = 0;
+      return true;
+    }
+  }, {
+    key: "_getBitsPerPixelInPalette",
+    value: function _getBitsPerPixelInPalette(paletteSize) {
+      if (paletteSize <= 2) {
+        return 1;
+      } else if (paletteSize <= 4) {
+        return 2;
+      } else if (paletteSize <= 16) {
+        return 4;
+      }
+    }
+  }, {
+    key: "_readPixels",
+    value: function _readPixels(pixels) {
+      var data = this._pixelBuffer;
+
+      var buffer = this._inflator.inflate(3 * pixels);
+
+      for (var i = 0, j = 0; i < pixels * 4; i += 4, j += 3) {
+        data[i] = buffer[j];
+        data[i + 1] = buffer[j + 1];
+        data[i + 2] = buffer[j + 2];
+        data[i + 3] = 255; // Add the Alpha
+      }
+
+      return data;
+    }
+  }, {
+    key: "_decodePaletteTile",
+    value: function _decodePaletteTile(paletteSize, tileSize, tilew, tileh) {
+      var data = this._tileBuffer;
+
+      var palette = this._readPixels(paletteSize);
+
+      var bitsPerPixel = this._getBitsPerPixelInPalette(paletteSize);
+
+      var mask = (1 << bitsPerPixel) - 1;
+      var offset = 0;
+
+      var encoded = this._inflator.inflate(1)[0];
+
+      for (var y = 0; y < tileh; y++) {
+        var shift = 8 - bitsPerPixel;
+
+        for (var x = 0; x < tilew; x++) {
+          if (shift < 0) {
+            shift = 8 - bitsPerPixel;
+            encoded = this._inflator.inflate(1)[0];
+          }
+
+          var indexInPalette = encoded >> shift & mask;
+          data[offset] = palette[indexInPalette * 4];
+          data[offset + 1] = palette[indexInPalette * 4 + 1];
+          data[offset + 2] = palette[indexInPalette * 4 + 2];
+          data[offset + 3] = palette[indexInPalette * 4 + 3];
+          offset += 4;
+          shift -= bitsPerPixel;
+        }
+
+        if (shift < 8 - bitsPerPixel && y < tileh - 1) {
+          encoded = this._inflator.inflate(1)[0];
+        }
+      }
+
+      return data;
+    }
+  }, {
+    key: "_decodeRLETile",
+    value: function _decodeRLETile(tileSize) {
+      var data = this._tileBuffer;
+      var i = 0;
+
+      while (i < tileSize) {
+        var pixel = this._readPixels(1);
+
+        var length = this._readRLELength();
+
+        for (var j = 0; j < length; j++) {
+          data[i * 4] = pixel[0];
+          data[i * 4 + 1] = pixel[1];
+          data[i * 4 + 2] = pixel[2];
+          data[i * 4 + 3] = pixel[3];
+          i++;
+        }
+      }
+
+      return data;
+    }
+  }, {
+    key: "_decodeRLEPaletteTile",
+    value: function _decodeRLEPaletteTile(paletteSize, tileSize) {
+      var data = this._tileBuffer; // palette
+
+      var palette = this._readPixels(paletteSize);
+
+      var offset = 0;
+
+      while (offset < tileSize) {
+        var indexInPalette = this._inflator.inflate(1)[0];
+
+        var length = 1;
+
+        if (indexInPalette >= 128) {
+          indexInPalette -= 128;
+          length = this._readRLELength();
+        }
+
+        if (indexInPalette > paletteSize) {
+          throw new Error('Too big index in palette: ' + indexInPalette + ', palette size: ' + paletteSize);
+        }
+
+        if (offset + length > tileSize) {
+          throw new Error('Too big rle length in palette mode: ' + length + ', allowed length is: ' + (tileSize - offset));
+        }
+
+        for (var j = 0; j < length; j++) {
+          data[offset * 4] = palette[indexInPalette * 4];
+          data[offset * 4 + 1] = palette[indexInPalette * 4 + 1];
+          data[offset * 4 + 2] = palette[indexInPalette * 4 + 2];
+          data[offset * 4 + 3] = palette[indexInPalette * 4 + 3];
+          offset++;
+        }
+      }
+
+      return data;
+    }
+  }, {
+    key: "_readRLELength",
+    value: function _readRLELength() {
+      var length = 0;
+      var current = 0;
+
+      do {
+        current = this._inflator.inflate(1)[0];
+        length += current;
+      } while (current === 255);
+
+      return length + 1;
+    }
+  }]);
+
+  return ZRLEDecoder;
+}();
+
+exports["default"] = ZRLEDecoder;

package/lib/encodings.js

@@ -19,7 +19,9 @@ var encodings = {
   encodingRRE: 2,
   encodingHextile: 5,
   encodingTight: 7,
+  encodingZRLE: 16,
   encodingTightPNG: -260,
+  encodingJPEG: 21,
   pseudoEncodingQualityLevel9: -23,
   pseudoEncodingQualityLevel0: -32,
   pseudoEncodingDesktopSize: -223,
@@ -55,9 +57,15 @@ function encodingName(num) {
     case encodings.encodingTight:
       return "Tight";
 
+    case encodings.encodingZRLE:
+      return "ZRLE";
+
     case encodings.encodingTightPNG:
       return "TightPNG";
 
+    case encodings.encodingJPEG:
+      return "JPEG";
+
     default:
       return "[unknown encoding " + num + "]";
   }

package/lib/input/util.js

@@ -5,8 +5,8 @@ function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "functi
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getKeycode = getKeycode;
 exports.getKey = getKey;
+exports.getKeycode = getKeycode;
 exports.getKeysym = getKeysym;
 
 var _keysym = _interopRequireDefault(require("./keysym.js"));

package/lib/rfb.js

@@ -55,6 +55,10 @@ var _tight = _interopRequireDefault(require("./decoders/tight.js"));
 
 var _tightpng = _interopRequireDefault(require("./decoders/tightpng.js"));
 
+var _zrle = _interopRequireDefault(require("./decoders/zrle.js"));
+
+var _jpeg = _interopRequireDefault(require("./decoders/jpeg.js"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
@@ -262,7 +266,9 @@ var RFB = /*#__PURE__*/function (_EventTargetMixin) {
     _this._decoders[_encodings.encodings.encodingRRE] = new _rre["default"]();
     _this._decoders[_encodings.encodings.encodingHextile] = new _hextile["default"]();
     _this._decoders[_encodings.encodings.encodingTight] = new _tight["default"]();
-    _this._decoders[_encodings.encodings.encodingTightPNG] = new _tightpng["default"](); // NB: nothing that needs explicit teardown should be done
+    _this._decoders[_encodings.encodings.encodingTightPNG] = new _tightpng["default"]();
+    _this._decoders[_encodings.encodings.encodingZRLE] = new _zrle["default"]();
+    _this._decoders[_encodings.encodings.encodingJPEG] = new _jpeg["default"](); // NB: nothing that needs explicit teardown should be done
     // before this point, since this can throw an exception
 
     try {
@@ -522,8 +528,8 @@ var RFB = /*#__PURE__*/function (_EventTargetMixin) {
     }
   }, {
     key: "focus",
-    value: function focus() {
-      this._canvas.focus();
+    value: function focus(options) {
+      this._canvas.focus(options);
     }
   }, {
     key: "blur",
@@ -746,7 +752,9 @@ var RFB = /*#__PURE__*/function (_EventTargetMixin) {
         return;
       }
 
-      this.focus();
+      this.focus({
+        preventScroll: true
+      });
     }
   }, {
     key: "_setDesktopName",
@@ -2150,6 +2158,8 @@ var RFB = /*#__PURE__*/function (_EventTargetMixin) {
       if (this._fbDepth == 24) {
         encs.push(_encodings.encodings.encodingTight);
         encs.push(_encodings.encodings.encodingTightPNG);
+        encs.push(_encodings.encodings.encodingZRLE);
+        encs.push(_encodings.encodings.encodingJPEG);
         encs.push(_encodings.encodings.encodingHextile);
         encs.push(_encodings.encodings.encodingRRE);
       }

package/lib/util/browser.js

@@ -5,12 +5,14 @@ function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "functi
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isMac = isMac;
-exports.isWindows = isWindows;
+exports.hasScrollbarGutter = exports.dragThreshold = void 0;
+exports.isFirefox = isFirefox;
 exports.isIOS = isIOS;
+exports.isMac = isMac;
 exports.isSafari = isSafari;
-exports.isFirefox = isFirefox;
-exports.hasScrollbarGutter = exports.supportsCursorURIs = exports.dragThreshold = exports.isTouchDevice = void 0;
+exports.isTouchDevice = void 0;
+exports.isWindows = isWindows;
+exports.supportsCursorURIs = void 0;
 
 var Log = _interopRequireWildcard(require("./logging.js"));
 
@@ -28,7 +30,9 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
  * Browser feature support detection
  */
 // Touch detection
-var isTouchDevice = 'ontouchstart' in document.documentElement || document.ontouchstart !== undefined || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0;
+var isTouchDevice = 'ontouchstart' in document.documentElement || // requried for Chrome debugger
+document.ontouchstart !== undefined || // required for MS Surface
+navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0;
 exports.isTouchDevice = isTouchDevice;
 window.addEventListener('touchstart', function onFirstTouch() {
   exports.isTouchDevice = isTouchDevice = true;

package/lib/util/events.js

@@ -4,9 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getPointerEvent = getPointerEvent;
-exports.stopEvent = stopEvent;
-exports.setCapture = setCapture;
 exports.releaseCapture = releaseCapture;
+exports.setCapture = setCapture;
+exports.stopEvent = stopEvent;
 
 /*
  * noVNC: HTML5 VNC client

package/lib/util/int.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.toUnsigned32bit = toUnsigned32bit;
 exports.toSigned32bit = toSigned32bit;
+exports.toUnsigned32bit = toUnsigned32bit;
 
 /*
  * noVNC: HTML5 VNC client

package/lib/util/logging.js

@@ -3,9 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.initLogging = initLogging;
+exports.Warn = exports.Info = exports.Error = exports.Debug = void 0;
 exports.getLogging = getLogging;
-exports.Error = exports.Warn = exports.Info = exports.Debug = void 0;
+exports.initLogging = initLogging;
 
 /*
  * noVNC: HTML5 VNC client

package/lib/vendor/pako/lib/utils/common.js

@@ -3,10 +3,10 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.shrinkBuf = shrinkBuf;
+exports.Buf8 = exports.Buf32 = exports.Buf16 = void 0;
 exports.arraySet = arraySet;
 exports.flattenChunks = flattenChunks;
-exports.Buf32 = exports.Buf16 = exports.Buf8 = void 0;
+exports.shrinkBuf = shrinkBuf;
 
 // reduce buffer size, avoiding mem copy
 function shrinkBuf(buf, size) {

package/lib/vendor/pako/lib/zlib/deflate.js

@@ -5,15 +5,16 @@ function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "functi
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.Z_UNKNOWN = exports.Z_STREAM_ERROR = exports.Z_STREAM_END = exports.Z_RLE = exports.Z_PARTIAL_FLUSH = exports.Z_OK = exports.Z_NO_FLUSH = exports.Z_HUFFMAN_ONLY = exports.Z_FULL_FLUSH = exports.Z_FIXED = exports.Z_FINISH = exports.Z_FILTERED = exports.Z_DEFLATED = exports.Z_DEFAULT_STRATEGY = exports.Z_DEFAULT_COMPRESSION = exports.Z_DATA_ERROR = exports.Z_BUF_ERROR = exports.Z_BLOCK = void 0;
+exports.deflate = deflate;
+exports.deflateEnd = deflateEnd;
+exports.deflateInfo = void 0;
 exports.deflateInit = deflateInit;
 exports.deflateInit2 = deflateInit2;
 exports.deflateReset = deflateReset;
 exports.deflateResetKeep = deflateResetKeep;
-exports.deflateSetHeader = deflateSetHeader;
-exports.deflate = deflate;
-exports.deflateEnd = deflateEnd;
 exports.deflateSetDictionary = deflateSetDictionary;
-exports.deflateInfo = exports.Z_DEFLATED = exports.Z_UNKNOWN = exports.Z_DEFAULT_STRATEGY = exports.Z_FIXED = exports.Z_RLE = exports.Z_HUFFMAN_ONLY = exports.Z_FILTERED = exports.Z_DEFAULT_COMPRESSION = exports.Z_BUF_ERROR = exports.Z_DATA_ERROR = exports.Z_STREAM_ERROR = exports.Z_STREAM_END = exports.Z_OK = exports.Z_BLOCK = exports.Z_FINISH = exports.Z_FULL_FLUSH = exports.Z_PARTIAL_FLUSH = exports.Z_NO_FLUSH = void 0;
+exports.deflateSetHeader = deflateSetHeader;
 
 var utils = _interopRequireWildcard(require("../utils/common.js"));
 

package/lib/vendor/pako/lib/zlib/inffast.js

@@ -392,7 +392,9 @@ function inflate_fast(strm, start) {
             }
           } else if ((op & 64) === 0) {
             /* 2nd level distance code */
-            here = dcode[(here & 0xffff) + (hold & (1 << op) - 1)];
+            here = dcode[(here & 0xffff
+            /*here.val*/
+            ) + (hold & (1 << op) - 1)];
             continue dodist;
           } else {
             strm.msg = 'invalid distance code';
@@ -404,7 +406,9 @@ function inflate_fast(strm, start) {
         }
       } else if ((op & 64) === 0) {
         /* 2nd level length code */
-        here = lcode[(here & 0xffff) + (hold & (1 << op) - 1)];
+        here = lcode[(here & 0xffff
+        /*here.val*/
+        ) + (hold & (1 << op) - 1)];
         continue dolen;
       } else if (op & 32) {
         /* end-of-block */

package/lib/vendor/pako/lib/zlib/inflate.js

@@ -5,16 +5,17 @@ function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "functi
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.inflateReset = inflateReset;
-exports.inflateReset2 = inflateReset2;
-exports.inflateResetKeep = inflateResetKeep;
-exports.inflateInit = inflateInit;
-exports.inflateInit2 = inflateInit2;
+exports.Z_TREES = exports.Z_STREAM_ERROR = exports.Z_STREAM_END = exports.Z_OK = exports.Z_NEED_DICT = exports.Z_MEM_ERROR = exports.Z_FINISH = exports.Z_DEFLATED = exports.Z_DATA_ERROR = exports.Z_BUF_ERROR = exports.Z_BLOCK = void 0;
 exports.inflate = inflate;
 exports.inflateEnd = inflateEnd;
 exports.inflateGetHeader = inflateGetHeader;
+exports.inflateInfo = void 0;
+exports.inflateInit = inflateInit;
+exports.inflateInit2 = inflateInit2;
+exports.inflateReset = inflateReset;
+exports.inflateReset2 = inflateReset2;
+exports.inflateResetKeep = inflateResetKeep;
 exports.inflateSetDictionary = inflateSetDictionary;
-exports.inflateInfo = exports.Z_DEFLATED = exports.Z_BUF_ERROR = exports.Z_MEM_ERROR = exports.Z_DATA_ERROR = exports.Z_STREAM_ERROR = exports.Z_NEED_DICT = exports.Z_STREAM_END = exports.Z_OK = exports.Z_TREES = exports.Z_BLOCK = exports.Z_FINISH = void 0;
 
 var utils = _interopRequireWildcard(require("../utils/common.js"));
 
@@ -693,13 +694,17 @@ function inflate(strm, flush) {
 
         if (!(state.wrap & 1) ||
         /* check if zlib header allowed */
-        (((hold & 0xff) << 8) + (hold >> 8)) % 31) {
+        (((hold & 0xff
+        /*BITS(8)*/
+        ) << 8) + (hold >> 8)) % 31) {
           strm.msg = 'incorrect header check';
           state.mode = BAD;
           break;
         }
 
-        if ((hold & 0x0f) !== Z_DEFLATED) {
+        if ((hold & 0x0f
+        /*BITS(4)*/
+        ) !== Z_DEFLATED) {
           strm.msg = 'unknown compression method';
           state.mode = BAD;
           break;
@@ -709,7 +714,9 @@ function inflate(strm, flush) {
         hold >>>= 4;
         bits -= 4; //---//
 
-        len = (hold & 0x0f) + 8;
+        len = (hold & 0x0f
+        /*BITS(4)*/
+        ) + 8;
 
         if (state.wbits === 0) {
           state.wbits = len;
@@ -1117,7 +1124,9 @@ function inflate(strm, flush) {
         hold >>>= 1;
         bits -= 1; //---//
 
-        switch (hold & 0x03) {
+        switch (hold & 0x03
+        /*BITS(2)*/
+        ) {
           case 0:
             /* stored block */
             //Tracev((stderr, "inflate:     stored block%s\n",
@@ -1248,17 +1257,23 @@ function inflate(strm, flush) {
         } //===//
 
 
-        state.nlen = (hold & 0x1f) + 257; //--- DROPBITS(5) ---//
+        state.nlen = (hold & 0x1f
+        /*BITS(5)*/
+        ) + 257; //--- DROPBITS(5) ---//
 
         hold >>>= 5;
         bits -= 5; //---//
 
-        state.ndist = (hold & 0x1f) + 1; //--- DROPBITS(5) ---//
+        state.ndist = (hold & 0x1f
+        /*BITS(5)*/
+        ) + 1; //--- DROPBITS(5) ---//
 
         hold >>>= 5;
         bits -= 5; //---//
 
-        state.ncode = (hold & 0x0f) + 4; //--- DROPBITS(4) ---//
+        state.ncode = (hold & 0x0f
+        /*BITS(4)*/
+        ) + 4; //--- DROPBITS(4) ---//
 
         hold >>>= 4;
         bits -= 4; //---//
@@ -1575,7 +1590,9 @@ function inflate(strm, flush) {
           last_val = here_val;
 
           for (;;) {
-            here = state.lencode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)];
+            here = state.lencode[last_val + ((hold & (1 << last_bits + last_op) - 1
+            /*BITS(last.bits + last.op)*/
+            ) >> last_bits)];
             here_bits = here >>> 24;
             here_op = here >>> 16 & 0xff;
             here_val = here & 0xffff;
@@ -1695,7 +1712,9 @@ function inflate(strm, flush) {
           last_val = here_val;
 
           for (;;) {
-            here = state.distcode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)];
+            here = state.distcode[last_val + ((hold & (1 << last_bits + last_op) - 1
+            /*BITS(last.bits + last.op)*/
+            ) >> last_bits)];
             here_bits = here >>> 24;
             here_op = here >>> 16 & 0xff;
             here_val = here & 0xffff;
@@ -1878,7 +1897,9 @@ function inflate(strm, flush) {
           state.total += _out;
 
           if (_out) {
-            strm.adler = state.check = state.flags ? (0, _crc["default"])(state.check, output, _out, put - _out) : (0, _adler["default"])(state.check, output, _out, put - _out);
+            strm.adler = state.check =
+            /*UPDATE(state.check, put - _out, _out);*/
+            state.flags ? (0, _crc["default"])(state.check, output, _out, put - _out) : (0, _adler["default"])(state.check, output, _out, put - _out);
           }
 
           _out = left; // NB: crc32 stored as signed 32-bit int, zswap32 returns signed too
@@ -1978,7 +1999,9 @@ function inflate(strm, flush) {
   state.total += _out;
 
   if (state.wrap && _out) {
-    strm.adler = state.check = state.flags ? (0, _crc["default"])(state.check, output, _out, strm.next_out - _out) : (0, _adler["default"])(state.check, output, _out, strm.next_out - _out);
+    strm.adler = state.check =
+    /*UPDATE(state.check, strm.next_out - _out, _out);*/
+    state.flags ? (0, _crc["default"])(state.check, output, _out, strm.next_out - _out) : (0, _adler["default"])(state.check, output, _out, strm.next_out - _out);
   }
 
   strm.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === TYPE ? 128 : 0) + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);

package/lib/vendor/pako/lib/zlib/trees.js

@@ -5,11 +5,11 @@ function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "functi
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports._tr_align = _tr_align;
+exports._tr_flush_block = _tr_flush_block;
 exports._tr_init = _tr_init;
 exports._tr_stored_block = _tr_stored_block;
-exports._tr_flush_block = _tr_flush_block;
 exports._tr_tally = _tr_tally;
-exports._tr_align = _tr_align;
 
 var utils = _interopRequireWildcard(require("../utils/common.js"));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@novnc/novnc",
-  "version": "1.3.0-beta",
+  "version": "1.3.0-g6710410",
   "description": "An HTML5 VNC client",
   "browser": "lib/rfb",
   "directories": {
@@ -29,8 +29,6 @@
   },
   "author": "Joel Martin <github@martintribe.org> (https://github.com/kanaka)",
   "contributors": [
-    "Solly Ross <sross@redhat.com> (https://github.com/directxman12)",
-    "Peter Åstrand <astrand@cendio.se> (https://github.com/astrand)",
     "Samuel Mannehed <samuel@cendio.se> (https://github.com/samhed)",
     "Pierre Ossman <ossman@cendio.se> (https://github.com/CendioOssman)"
   ],