@novnc/novnc 1.0.0 → 1.2.0

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

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = ZStream;
+
+function ZStream() {
+  /* next input byte */
+  this.input = null; // JS specific, because we have no pointers
+
+  this.next_in = 0;
+  /* number of bytes available at input */
+
+  this.avail_in = 0;
+  /* total number of input bytes read so far */
+
+  this.total_in = 0;
+  /* next output byte should be put there */
+
+  this.output = null; // JS specific, because we have no pointers
+
+  this.next_out = 0;
+  /* remaining free space at output */
+
+  this.avail_out = 0;
+  /* total number of bytes output so far */
+
+  this.total_out = 0;
+  /* last error message, NULL if no error */
+
+  this.msg = ''
+  /*Z_NULL*/
+  ;
+  /* not visible by applications */
+
+  this.state = null;
+  /* best guess about the data type: binary or text */
+
+  this.data_type = 2
+  /*Z_UNKNOWN*/
+  ;
+  /* adler32 value of the uncompressed data */
+
+  this.adler = 0;
+}

package/lib/vendor/promise.js

@@ -0,0 +1,255 @@
+/* Copyright (c) 2014 Taylor Hakes
+ * Copyright (c) 2014 Forbes Lindesay
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+(function (root) {
+
+  // Store setTimeout reference so promise-polyfill will be unaffected by
+  // other code modifying setTimeout (like sinon.useFakeTimers())
+  var setTimeoutFunc = setTimeout;
+
+  function noop() {}
+  
+  // Polyfill for Function.prototype.bind
+  function bind(fn, thisArg) {
+    return function () {
+      fn.apply(thisArg, arguments);
+    };
+  }
+
+  function Promise(fn) {
+    if (typeof this !== 'object') throw new TypeError('Promises must be constructed via new');
+    if (typeof fn !== 'function') throw new TypeError('not a function');
+    this._state = 0;
+    this._handled = false;
+    this._value = undefined;
+    this._deferreds = [];
+
+    doResolve(fn, this);
+  }
+
+  function handle(self, deferred) {
+    while (self._state === 3) {
+      self = self._value;
+    }
+    if (self._state === 0) {
+      self._deferreds.push(deferred);
+      return;
+    }
+    self._handled = true;
+    Promise._immediateFn(function () {
+      var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;
+      if (cb === null) {
+        (self._state === 1 ? resolve : reject)(deferred.promise, self._value);
+        return;
+      }
+      var ret;
+      try {
+        ret = cb(self._value);
+      } catch (e) {
+        reject(deferred.promise, e);
+        return;
+      }
+      resolve(deferred.promise, ret);
+    });
+  }
+
+  function resolve(self, newValue) {
+    try {
+      // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
+      if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.');
+      if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
+        var then = newValue.then;
+        if (newValue instanceof Promise) {
+          self._state = 3;
+          self._value = newValue;
+          finale(self);
+          return;
+        } else if (typeof then === 'function') {
+          doResolve(bind(then, newValue), self);
+          return;
+        }
+      }
+      self._state = 1;
+      self._value = newValue;
+      finale(self);
+    } catch (e) {
+      reject(self, e);
+    }
+  }
+
+  function reject(self, newValue) {
+    self._state = 2;
+    self._value = newValue;
+    finale(self);
+  }
+
+  function finale(self) {
+    if (self._state === 2 && self._deferreds.length === 0) {
+      Promise._immediateFn(function() {
+        if (!self._handled) {
+          Promise._unhandledRejectionFn(self._value);
+        }
+      });
+    }
+
+    for (var i = 0, len = self._deferreds.length; i < len; i++) {
+      handle(self, self._deferreds[i]);
+    }
+    self._deferreds = null;
+  }
+
+  function Handler(onFulfilled, onRejected, promise) {
+    this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
+    this.onRejected = typeof onRejected === 'function' ? onRejected : null;
+    this.promise = promise;
+  }
+
+  /**
+   * Take a potentially misbehaving resolver function and make sure
+   * onFulfilled and onRejected are only called once.
+   *
+   * Makes no guarantees about asynchrony.
+   */
+  function doResolve(fn, self) {
+    var done = false;
+    try {
+      fn(function (value) {
+        if (done) return;
+        done = true;
+        resolve(self, value);
+      }, function (reason) {
+        if (done) return;
+        done = true;
+        reject(self, reason);
+      });
+    } catch (ex) {
+      if (done) return;
+      done = true;
+      reject(self, ex);
+    }
+  }
+
+  Promise.prototype['catch'] = function (onRejected) {
+    return this.then(null, onRejected);
+  };
+
+  Promise.prototype.then = function (onFulfilled, onRejected) {
+    var prom = new (this.constructor)(noop);
+
+    handle(this, new Handler(onFulfilled, onRejected, prom));
+    return prom;
+  };
+
+  Promise.all = function (arr) {
+    var args = Array.prototype.slice.call(arr);
+
+    return new Promise(function (resolve, reject) {
+      if (args.length === 0) return resolve([]);
+      var remaining = args.length;
+
+      function res(i, val) {
+        try {
+          if (val && (typeof val === 'object' || typeof val === 'function')) {
+            var then = val.then;
+            if (typeof then === 'function') {
+              then.call(val, function (val) {
+                res(i, val);
+              }, reject);
+              return;
+            }
+          }
+          args[i] = val;
+          if (--remaining === 0) {
+            resolve(args);
+          }
+        } catch (ex) {
+          reject(ex);
+        }
+      }
+
+      for (var i = 0; i < args.length; i++) {
+        res(i, args[i]);
+      }
+    });
+  };
+
+  Promise.resolve = function (value) {
+    if (value && typeof value === 'object' && value.constructor === Promise) {
+      return value;
+    }
+
+    return new Promise(function (resolve) {
+      resolve(value);
+    });
+  };
+
+  Promise.reject = function (value) {
+    return new Promise(function (resolve, reject) {
+      reject(value);
+    });
+  };
+
+  Promise.race = function (values) {
+    return new Promise(function (resolve, reject) {
+      for (var i = 0, len = values.length; i < len; i++) {
+        values[i].then(resolve, reject);
+      }
+    });
+  };
+
+  // Use polyfill for setImmediate for performance gains
+  Promise._immediateFn = (typeof setImmediate === 'function' && function (fn) { setImmediate(fn); }) ||
+    function (fn) {
+      setTimeoutFunc(fn, 0);
+    };
+
+  Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) {
+    if (typeof console !== 'undefined' && console) {
+      console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console
+    }
+  };
+
+  /**
+   * Set the immediate function to execute callbacks
+   * @param fn {function} Function to execute
+   * @deprecated
+   */
+  Promise._setImmediateFn = function _setImmediateFn(fn) {
+    Promise._immediateFn = fn;
+  };
+
+  /**
+   * Change the function to execute on unhandled rejection
+   * @param {function} fn Function to execute on unhandled rejection
+   * @deprecated
+   */
+  Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {
+    Promise._unhandledRejectionFn = fn;
+  };
+  
+  if (typeof module !== 'undefined' && module.exports) {
+    module.exports = Promise;
+  } else if (!root.Promise) {
+    root.Promise = Promise;
+  }
+
+})(this);

package/lib/websock.js

@@ -0,0 +1,374 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var Log = _interopRequireWildcard(require("./util/logging.js"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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; }
+
+// this has performance issues in some versions Chromium, and
+// doesn't gain a tremendous amount of performance increase in Firefox
+// at the moment.  It may be valuable to turn it on in the future.
+// Also copyWithin() for TypedArrays is not supported in IE 11 or
+// Safari 13 (at the moment we want to support Safari 11).
+var ENABLE_COPYWITHIN = false;
+var MAX_RQ_GROW_SIZE = 40 * 1024 * 1024; // 40 MiB
+
+var Websock = /*#__PURE__*/function () {
+  function Websock() {
+    _classCallCheck(this, Websock);
+
+    this._websocket = null; // WebSocket object
+
+    this._rQi = 0; // Receive queue index
+
+    this._rQlen = 0; // Next write position in the receive queue
+
+    this._rQbufferSize = 1024 * 1024 * 4; // Receive queue buffer size (4 MiB)
+    // called in init: this._rQ = new Uint8Array(this._rQbufferSize);
+
+    this._rQ = null; // Receive queue
+
+    this._sQbufferSize = 1024 * 10; // 10 KiB
+    // called in init: this._sQ = new Uint8Array(this._sQbufferSize);
+
+    this._sQlen = 0;
+    this._sQ = null; // Send queue
+
+    this._eventHandlers = {
+      message: function message() {},
+      open: function open() {},
+      close: function close() {},
+      error: function error() {}
+    };
+  } // Getters and Setters
+
+
+  _createClass(Websock, [{
+    key: "rQpeek8",
+    value: function rQpeek8() {
+      return this._rQ[this._rQi];
+    }
+  }, {
+    key: "rQskipBytes",
+    value: function rQskipBytes(bytes) {
+      this._rQi += bytes;
+    }
+  }, {
+    key: "rQshift8",
+    value: function rQshift8() {
+      return this._rQshift(1);
+    }
+  }, {
+    key: "rQshift16",
+    value: function rQshift16() {
+      return this._rQshift(2);
+    }
+  }, {
+    key: "rQshift32",
+    value: function rQshift32() {
+      return this._rQshift(4);
+    } // TODO(directxman12): test performance with these vs a DataView
+
+  }, {
+    key: "_rQshift",
+    value: function _rQshift(bytes) {
+      var res = 0;
+
+      for (var byte = bytes - 1; byte >= 0; byte--) {
+        res += this._rQ[this._rQi++] << byte * 8;
+      }
+
+      return res;
+    }
+  }, {
+    key: "rQshiftStr",
+    value: function rQshiftStr(len) {
+      if (typeof len === 'undefined') {
+        len = this.rQlen;
+      }
+
+      var str = ""; // Handle large arrays in steps to avoid long strings on the stack
+
+      for (var i = 0; i < len; i += 4096) {
+        var part = this.rQshiftBytes(Math.min(4096, len - i));
+        str += String.fromCharCode.apply(null, part);
+      }
+
+      return str;
+    }
+  }, {
+    key: "rQshiftBytes",
+    value: function rQshiftBytes(len) {
+      if (typeof len === 'undefined') {
+        len = this.rQlen;
+      }
+
+      this._rQi += len;
+      return new Uint8Array(this._rQ.buffer, this._rQi - len, len);
+    }
+  }, {
+    key: "rQshiftTo",
+    value: function rQshiftTo(target, len) {
+      if (len === undefined) {
+        len = this.rQlen;
+      } // TODO: make this just use set with views when using a ArrayBuffer to store the rQ
+
+
+      target.set(new Uint8Array(this._rQ.buffer, this._rQi, len));
+      this._rQi += len;
+    }
+  }, {
+    key: "rQslice",
+    value: function rQslice(start) {
+      var end = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.rQlen;
+      return new Uint8Array(this._rQ.buffer, this._rQi + start, end - start);
+    } // Check to see if we must wait for 'num' bytes (default to FBU.bytes)
+    // to be available in the receive queue. Return true if we need to
+    // wait (and possibly print a debug message), otherwise false.
+
+  }, {
+    key: "rQwait",
+    value: function rQwait(msg, num, goback) {
+      if (this.rQlen < num) {
+        if (goback) {
+          if (this._rQi < goback) {
+            throw new Error("rQwait cannot backup " + goback + " bytes");
+          }
+
+          this._rQi -= goback;
+        }
+
+        return true; // true means need more data
+      }
+
+      return false;
+    } // Send Queue
+
+  }, {
+    key: "flush",
+    value: function flush() {
+      if (this._sQlen > 0 && this._websocket.readyState === WebSocket.OPEN) {
+        this._websocket.send(this._encodeMessage());
+
+        this._sQlen = 0;
+      }
+    }
+  }, {
+    key: "send",
+    value: function send(arr) {
+      this._sQ.set(arr, this._sQlen);
+
+      this._sQlen += arr.length;
+      this.flush();
+    }
+  }, {
+    key: "sendString",
+    value: function sendString(str) {
+      this.send(str.split('').map(function (chr) {
+        return chr.charCodeAt(0);
+      }));
+    } // Event Handlers
+
+  }, {
+    key: "off",
+    value: function off(evt) {
+      this._eventHandlers[evt] = function () {};
+    }
+  }, {
+    key: "on",
+    value: function on(evt, handler) {
+      this._eventHandlers[evt] = handler;
+    }
+  }, {
+    key: "_allocateBuffers",
+    value: function _allocateBuffers() {
+      this._rQ = new Uint8Array(this._rQbufferSize);
+      this._sQ = new Uint8Array(this._sQbufferSize);
+    }
+  }, {
+    key: "init",
+    value: function init() {
+      this._allocateBuffers();
+
+      this._rQi = 0;
+      this._websocket = null;
+    }
+  }, {
+    key: "open",
+    value: function open(uri, protocols) {
+      var _this = this;
+
+      this.init();
+      this._websocket = new WebSocket(uri, protocols);
+      this._websocket.binaryType = 'arraybuffer';
+      this._websocket.onmessage = this._recvMessage.bind(this);
+
+      this._websocket.onopen = function () {
+        Log.Debug('>> WebSock.onopen');
+
+        if (_this._websocket.protocol) {
+          Log.Info("Server choose sub-protocol: " + _this._websocket.protocol);
+        }
+
+        _this._eventHandlers.open();
+
+        Log.Debug("<< WebSock.onopen");
+      };
+
+      this._websocket.onclose = function (e) {
+        Log.Debug(">> WebSock.onclose");
+
+        _this._eventHandlers.close(e);
+
+        Log.Debug("<< WebSock.onclose");
+      };
+
+      this._websocket.onerror = function (e) {
+        Log.Debug(">> WebSock.onerror: " + e);
+
+        _this._eventHandlers.error(e);
+
+        Log.Debug("<< WebSock.onerror: " + e);
+      };
+    }
+  }, {
+    key: "close",
+    value: function close() {
+      if (this._websocket) {
+        if (this._websocket.readyState === WebSocket.OPEN || this._websocket.readyState === WebSocket.CONNECTING) {
+          Log.Info("Closing WebSocket connection");
+
+          this._websocket.close();
+        }
+
+        this._websocket.onmessage = function () {};
+      }
+    } // private methods
+
+  }, {
+    key: "_encodeMessage",
+    value: function _encodeMessage() {
+      // Put in a binary arraybuffer
+      // according to the spec, you can send ArrayBufferViews with the send method
+      return new Uint8Array(this._sQ.buffer, 0, this._sQlen);
+    } // We want to move all the unread data to the start of the queue,
+    // e.g. compacting.
+    // The function also expands the receive que if needed, and for
+    // performance reasons we combine these two actions to avoid
+    // unneccessary copying.
+
+  }, {
+    key: "_expandCompactRQ",
+    value: function _expandCompactRQ(minFit) {
+      // if we're using less than 1/8th of the buffer even with the incoming bytes, compact in place
+      // instead of resizing
+      var requiredBufferSize = (this._rQlen - this._rQi + minFit) * 8;
+      var resizeNeeded = this._rQbufferSize < requiredBufferSize;
+
+      if (resizeNeeded) {
+        // Make sure we always *at least* double the buffer size, and have at least space for 8x
+        // the current amount of data
+        this._rQbufferSize = Math.max(this._rQbufferSize * 2, requiredBufferSize);
+      } // we don't want to grow unboundedly
+
+
+      if (this._rQbufferSize > MAX_RQ_GROW_SIZE) {
+        this._rQbufferSize = MAX_RQ_GROW_SIZE;
+
+        if (this._rQbufferSize - this.rQlen < minFit) {
+          throw new Error("Receive Queue buffer exceeded " + MAX_RQ_GROW_SIZE + " bytes, and the new message could not fit");
+        }
+      }
+
+      if (resizeNeeded) {
+        var oldRQbuffer = this._rQ.buffer;
+        this._rQ = new Uint8Array(this._rQbufferSize);
+
+        this._rQ.set(new Uint8Array(oldRQbuffer, this._rQi, this._rQlen - this._rQi));
+      } else {
+        if (ENABLE_COPYWITHIN) {
+          this._rQ.copyWithin(0, this._rQi, this._rQlen);
+        } else {
+          this._rQ.set(new Uint8Array(this._rQ.buffer, this._rQi, this._rQlen - this._rQi));
+        }
+      }
+
+      this._rQlen = this._rQlen - this._rQi;
+      this._rQi = 0;
+    } // push arraybuffer values onto the end of the receive que
+
+  }, {
+    key: "_DecodeMessage",
+    value: function _DecodeMessage(data) {
+      var u8 = new Uint8Array(data);
+
+      if (u8.length > this._rQbufferSize - this._rQlen) {
+        this._expandCompactRQ(u8.length);
+      }
+
+      this._rQ.set(u8, this._rQlen);
+
+      this._rQlen += u8.length;
+    }
+  }, {
+    key: "_recvMessage",
+    value: function _recvMessage(e) {
+      this._DecodeMessage(e.data);
+
+      if (this.rQlen > 0) {
+        this._eventHandlers.message();
+
+        if (this._rQlen == this._rQi) {
+          // All data has now been processed, this means we
+          // can reset the receive queue.
+          this._rQlen = 0;
+          this._rQi = 0;
+        }
+      } else {
+        Log.Debug("Ignoring empty message");
+      }
+    }
+  }, {
+    key: "sQ",
+    get: function get() {
+      return this._sQ;
+    }
+  }, {
+    key: "rQ",
+    get: function get() {
+      return this._rQ;
+    }
+  }, {
+    key: "rQi",
+    get: function get() {
+      return this._rQi;
+    },
+    set: function set(val) {
+      this._rQi = val;
+    } // Receive Queue
+
+  }, {
+    key: "rQlen",
+    get: function get() {
+      return this._rQlen - this._rQi;
+    }
+  }]);
+
+  return Websock;
+}();
+
+exports.default = Websock;