@novnc/novnc 1.0.0 → 1.2.0

package/lib/util/int.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toUnsigned32bit = toUnsigned32bit;
+exports.toSigned32bit = toSigned32bit;
+
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2020 The noVNC Authors
+ * Licensed under MPL 2.0 (see LICENSE.txt)
+ *
+ * See README.md for usage and integration instructions.
+ */
+function toUnsigned32bit(toConvert) {
+  return toConvert >>> 0;
+}
+
+function toSigned32bit(toConvert) {
+  return toConvert | 0;
+}

package/lib/util/logging.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initLogging = initLogging;
+exports.getLogging = getLogging;
+exports.Error = exports.Warn = exports.Info = exports.Debug = void 0;
+
+/*
+ * 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.
+ */
+
+/*
+ * Logging/debug routines
+ */
+var _logLevel = 'warn';
+
+var Debug = function Debug() {};
+
+exports.Debug = Debug;
+
+var Info = function Info() {};
+
+exports.Info = Info;
+
+var Warn = function Warn() {};
+
+exports.Warn = Warn;
+
+var Error = function Error() {};
+
+exports.Error = Error;
+
+function initLogging(level) {
+  if (typeof level === 'undefined') {
+    level = _logLevel;
+  } else {
+    _logLevel = level;
+  }
+
+  exports.Debug = Debug = exports.Info = Info = exports.Warn = Warn = exports.Error = Error = function Error() {};
+
+  if (typeof window.console !== "undefined") {
+    /* eslint-disable no-console, no-fallthrough */
+    switch (level) {
+      case 'debug':
+        exports.Debug = Debug = console.debug.bind(window.console);
+
+      case 'info':
+        exports.Info = Info = console.info.bind(window.console);
+
+      case 'warn':
+        exports.Warn = Warn = console.warn.bind(window.console);
+
+      case 'error':
+        exports.Error = Error = console.error.bind(window.console);
+
+      case 'none':
+        break;
+
+      default:
+        throw new window.Error("invalid logging type '" + level + "'");
+    }
+    /* eslint-enable no-console, no-fallthrough */
+
+  }
+}
+
+function getLogging() {
+  return _logLevel;
+}
+
+// Initialize logging level
+initLogging();

package/lib/util/polyfill.js

@@ -0,0 +1,72 @@
+"use strict";
+
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2020 The noVNC Authors
+ * Licensed under MPL 2.0 or any later version (see LICENSE.txt)
+ */
+
+/* Polyfills to provide new APIs in old browsers */
+
+/* Object.assign() (taken from MDN) */
+if (typeof Object.assign != 'function') {
+  // Must be writable: true, enumerable: false, configurable: true
+  Object.defineProperty(Object, "assign", {
+    value: function assign(target, varArgs) {
+      // .length of function is 2
+      'use strict';
+
+      if (target == null) {
+        // TypeError if undefined or null
+        throw new TypeError('Cannot convert undefined or null to object');
+      }
+
+      var to = Object(target);
+
+      for (var index = 1; index < arguments.length; index++) {
+        var nextSource = arguments[index];
+
+        if (nextSource != null) {
+          // Skip over if undefined or null
+          for (var nextKey in nextSource) {
+            // Avoid bugs when hasOwnProperty is shadowed
+            if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+              to[nextKey] = nextSource[nextKey];
+            }
+          }
+        }
+      }
+
+      return to;
+    },
+    writable: true,
+    configurable: true
+  });
+}
+/* CustomEvent constructor (taken from MDN) */
+
+
+(function () {
+  function CustomEvent(event, params) {
+    params = params || {
+      bubbles: false,
+      cancelable: false,
+      detail: undefined
+    };
+    var evt = document.createEvent('CustomEvent');
+    evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
+    return evt;
+  }
+
+  CustomEvent.prototype = window.Event.prototype;
+
+  if (typeof window.CustomEvent !== "function") {
+    window.CustomEvent = CustomEvent;
+  }
+})();
+/* Number.isInteger() (taken from MDN) */
+
+
+Number.isInteger = Number.isInteger || function isInteger(value) {
+  return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
+};

package/lib/util/strings.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decodeUTF8 = decodeUTF8;
+exports.encodeUTF8 = encodeUTF8;
+
+/*
+ * 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.
+ */
+// Decode from UTF-8
+function decodeUTF8(utf8string) {
+  var allowLatin1 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+  try {
+    return decodeURIComponent(escape(utf8string));
+  } catch (e) {
+    if (e instanceof URIError) {
+      if (allowLatin1) {
+        // If we allow Latin1 we can ignore any decoding fails
+        // and in these cases return the original string
+        return utf8string;
+      }
+    }
+
+    throw e;
+  }
+} // Encode to UTF-8
+
+
+function encodeUTF8(DOMString) {
+  return unescape(encodeURIComponent(DOMString));
+}

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

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shrinkBuf = shrinkBuf;
+exports.arraySet = arraySet;
+exports.flattenChunks = flattenChunks;
+exports.Buf32 = exports.Buf16 = exports.Buf8 = void 0;
+
+// reduce buffer size, avoiding mem copy
+function shrinkBuf(buf, size) {
+  if (buf.length === size) {
+    return buf;
+  }
+
+  if (buf.subarray) {
+    return buf.subarray(0, size);
+  }
+
+  buf.length = size;
+  return buf;
+}
+
+;
+
+function arraySet(dest, src, src_offs, len, dest_offs) {
+  if (src.subarray && dest.subarray) {
+    dest.set(src.subarray(src_offs, src_offs + len), dest_offs);
+    return;
+  } // Fallback to ordinary array
+
+
+  for (var i = 0; i < len; i++) {
+    dest[dest_offs + i] = src[src_offs + i];
+  }
+} // Join array of chunks to single array.
+
+
+function flattenChunks(chunks) {
+  var i, l, len, pos, chunk, result; // calculate data length
+
+  len = 0;
+
+  for (i = 0, l = chunks.length; i < l; i++) {
+    len += chunks[i].length;
+  } // join chunks
+
+
+  result = new Uint8Array(len);
+  pos = 0;
+
+  for (i = 0, l = chunks.length; i < l; i++) {
+    chunk = chunks[i];
+    result.set(chunk, pos);
+    pos += chunk.length;
+  }
+
+  return result;
+}
+
+var Buf8 = Uint8Array;
+exports.Buf8 = Buf8;
+var Buf16 = Uint16Array;
+exports.Buf16 = Buf16;
+var Buf32 = Int32Array;
+exports.Buf32 = Buf32;

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

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = adler32;
+
+// Note: adler32 takes 12% for level 0 and 2% for level 6.
+// It doesn't worth to make additional optimizationa as in original.
+// Small size is preferable.
+function adler32(adler, buf, len, pos) {
+  var s1 = adler & 0xffff | 0,
+      s2 = adler >>> 16 & 0xffff | 0,
+      n = 0;
+
+  while (len !== 0) {
+    // Set limit ~ twice less than 5552, to keep
+    // s2 in 31-bits, because we force signed ints.
+    // in other case %= will fail.
+    n = len > 2000 ? 2000 : len;
+    len -= n;
+
+    do {
+      s1 = s1 + buf[pos++] | 0;
+      s2 = s2 + s1 | 0;
+    } while (--n);
+
+    s1 %= 65521;
+    s2 %= 65521;
+  }
+
+  return s1 | s2 << 16 | 0;
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {
+  /* Allowed flush values; see deflate() and inflate() below for details */
+  Z_NO_FLUSH: 0,
+  Z_PARTIAL_FLUSH: 1,
+  Z_SYNC_FLUSH: 2,
+  Z_FULL_FLUSH: 3,
+  Z_FINISH: 4,
+  Z_BLOCK: 5,
+  Z_TREES: 6,
+
+  /* Return codes for the compression/decompression functions. Negative values
+  * are errors, positive values are used for special but normal events.
+  */
+  Z_OK: 0,
+  Z_STREAM_END: 1,
+  Z_NEED_DICT: 2,
+  Z_ERRNO: -1,
+  Z_STREAM_ERROR: -2,
+  Z_DATA_ERROR: -3,
+  //Z_MEM_ERROR:     -4,
+  Z_BUF_ERROR: -5,
+  //Z_VERSION_ERROR: -6,
+
+  /* compression levels */
+  Z_NO_COMPRESSION: 0,
+  Z_BEST_SPEED: 1,
+  Z_BEST_COMPRESSION: 9,
+  Z_DEFAULT_COMPRESSION: -1,
+  Z_FILTERED: 1,
+  Z_HUFFMAN_ONLY: 2,
+  Z_RLE: 3,
+  Z_FIXED: 4,
+  Z_DEFAULT_STRATEGY: 0,
+
+  /* Possible values of the data_type field (though see inflate()) */
+  Z_BINARY: 0,
+  Z_TEXT: 1,
+  //Z_ASCII:                1, // = Z_TEXT (deprecated)
+  Z_UNKNOWN: 2,
+
+  /* The deflate compression method */
+  Z_DEFLATED: 8 //Z_NULL:                 null // Use -1 or null inline, depending on var type
+
+};
+exports.default = _default;

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

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = makeTable;
+
+// Note: we can't get significant speed boost here.
+// So write code to minimize size - no pregenerated tables
+// and array tools dependencies.
+// Use ordinary array, since untyped makes no boost here
+function makeTable() {
+  var c,
+      table = [];
+
+  for (var n = 0; n < 256; n++) {
+    c = n;
+
+    for (var k = 0; k < 8; k++) {
+      c = c & 1 ? 0xEDB88320 ^ c >>> 1 : c >>> 1;
+    }
+
+    table[n] = c;
+  }
+
+  return table;
+} // Create table on load. Just 255 signed longs. Not a problem.
+
+
+var crcTable = makeTable();
+
+function crc32(crc, buf, len, pos) {
+  var t = crcTable,
+      end = pos + len;
+  crc ^= -1;
+
+  for (var i = pos; i < end; i++) {
+    crc = crc >>> 8 ^ t[(crc ^ buf[i]) & 0xFF];
+  }
+
+  return crc ^ -1; // >>> 0;
+}