@novnc/novnc 1.3.0 → 1.4.0-beta

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

@@ -1,99 +1,58 @@
 "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); }
-
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports["default"] = inflate_table;
-
 var utils = _interopRequireWildcard(require("../utils/common.js"));
-
 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); }
-
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && 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; }
-
 var MAXBITS = 15;
 var ENOUGH_LENS = 852;
-var ENOUGH_DISTS = 592; //var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
+var ENOUGH_DISTS = 592;
+//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
 
 var CODES = 0;
 var LENS = 1;
 var DISTS = 2;
-var lbase = [
-/* Length codes 257..285 base */
+var lbase = [/* Length codes 257..285 base */
 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0];
-var lext = [
-/* Length codes 257..285 extra */
+var lext = [/* Length codes 257..285 extra */
 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78];
-var dbase = [
-/* Distance codes 0..29 base */
+var dbase = [/* Distance codes 0..29 base */
 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0];
-var dext = [
-/* Distance codes 0..29 extra */
+var dext = [/* Distance codes 0..29 extra */
 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 64, 64];
-
 function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts) {
-  var bits = opts.bits; //here = opts.here; /* table entry for duplication */
-
-  var len = 0;
-  /* a code's length in bits */
-
-  var sym = 0;
-  /* index of code symbols */
+  var bits = opts.bits;
+  //here = opts.here; /* table entry for duplication */
 
+  var len = 0; /* a code's length in bits */
+  var sym = 0; /* index of code symbols */
   var min = 0,
-      max = 0;
-  /* minimum and maximum code lengths */
-
-  var root = 0;
-  /* number of index bits for root table */
-
-  var curr = 0;
-  /* number of index bits for current table */
-
-  var drop = 0;
-  /* code bits to drop for sub-table */
-
-  var left = 0;
-  /* number of prefix codes available */
-
-  var used = 0;
-  /* code entries in table used */
-
-  var huff = 0;
-  /* Huffman code */
-
-  var incr;
-  /* for incrementing code, index */
-
-  var fill;
-  /* index for replicating entries */
-
-  var low;
-  /* low bits for current root entry */
-
-  var mask;
-  /* mask for low root bits */
-
-  var next;
-  /* next available space in table */
-
-  var base = null;
-  /* base value table to use */
-
-  var base_index = 0; //  var shoextra;    /* extra bits table to use */
-
-  var end;
-  /* use base and extra for symbol > end */
-
+    max = 0; /* minimum and maximum code lengths */
+  var root = 0; /* number of index bits for root table */
+  var curr = 0; /* number of index bits for current table */
+  var drop = 0; /* code bits to drop for sub-table */
+  var left = 0; /* number of prefix codes available */
+  var used = 0; /* code entries in table used */
+  var huff = 0; /* Huffman code */
+  var incr; /* for incrementing code, index */
+  var fill; /* index for replicating entries */
+  var low; /* low bits for current root entry */
+  var mask; /* mask for low root bits */
+  var next; /* next available space in table */
+  var base = null; /* base value table to use */
+  var base_index = 0;
+  //  var shoextra;    /* extra bits table to use */
+  var end; /* use base and extra for symbol > end */
   var count = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1];    /* number of codes of each length */
-
   var offs = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1];     /* offsets in table for each length */
-
   var extra = null;
   var extra_index = 0;
   var here_bits, here_op, here_val;
+
   /*
    Process a set of code lengths to create a canonical Huffman code.  The
    code lengths are lens[0..codes-1].  Each length corresponds to the
@@ -123,42 +82,36 @@ function inflate_table(type, lens, lens_index, codes, table, table_index, work,
    */
 
   /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
-
   for (len = 0; len <= MAXBITS; len++) {
     count[len] = 0;
   }
-
   for (sym = 0; sym < codes; sym++) {
     count[lens[lens_index + sym]]++;
   }
-  /* bound code lengths, force root to be within code lengths */
-
 
+  /* bound code lengths, force root to be within code lengths */
   root = bits;
-
   for (max = MAXBITS; max >= 1; max--) {
     if (count[max] !== 0) {
       break;
     }
   }
-
   if (root > max) {
     root = max;
   }
-
   if (max === 0) {
     /* no symbols to code at all */
     //table.op[opts.table_index] = 64;  //here.op = (var char)64;    /* invalid code marker */
     //table.bits[opts.table_index] = 1;   //here.bits = (var char)1;
     //table.val[opts.table_index++] = 0;   //here.val = (var short)0;
-    table[table_index++] = 1 << 24 | 64 << 16 | 0; //table.op[opts.table_index] = 64;
+    table[table_index++] = 1 << 24 | 64 << 16 | 0;
+
+    //table.op[opts.table_index] = 64;
     //table.bits[opts.table_index] = 1;
     //table.val[opts.table_index++] = 0;
-
     table[table_index++] = 1 << 24 | 64 << 16 | 0;
     opts.bits = 1;
-    return 0;
-    /* no symbols, but wait for decoding to report error */
+    return 0; /* no symbols, but wait for decoding to report error */
   }
 
   for (min = 1; min < max; min++) {
@@ -166,46 +119,37 @@ function inflate_table(type, lens, lens_index, codes, table, table_index, work,
       break;
     }
   }
-
   if (root < min) {
     root = min;
   }
-  /* check for an over-subscribed or incomplete set of lengths */
-
 
+  /* check for an over-subscribed or incomplete set of lengths */
   left = 1;
-
   for (len = 1; len <= MAXBITS; len++) {
     left <<= 1;
     left -= count[len];
-
     if (left < 0) {
       return -1;
-    }
-    /* over-subscribed */
-
+    } /* over-subscribed */
   }
 
   if (left > 0 && (type === CODES || max !== 1)) {
-    return -1;
-    /* incomplete set */
+    return -1; /* incomplete set */
   }
-  /* generate offsets into symbol table for each length for sorting */
-
 
+  /* generate offsets into symbol table for each length for sorting */
   offs[1] = 0;
-
   for (len = 1; len < MAXBITS; len++) {
     offs[len + 1] = offs[len] + count[len];
   }
-  /* sort symbols by length, by symbol order within each length */
-
 
+  /* sort symbols by length, by symbol order within each length */
   for (sym = 0; sym < codes; sym++) {
     if (lens[lens_index + sym] !== 0) {
       work[offs[lens[lens_index + sym]]++] = sym;
     }
   }
+
   /*
    Create and fill in decoding tables.  In this loop, the table being
    filled is at next and has curr index bits.  The code being used is huff
@@ -236,12 +180,8 @@ function inflate_table(type, lens, lens_index, codes, table, table_index, work,
   /* set up for code type */
   // poor man optimization - use if-else instead of switch,
   // to avoid deopts in old v8
-
-
   if (type === CODES) {
-    base = extra = work;
-    /* dummy value--not used */
-
+    base = extra = work; /* dummy value--not used */
     end = 19;
   } else if (type === LENS) {
     base = lbase;
@@ -255,48 +195,27 @@ function inflate_table(type, lens, lens_index, codes, table, table_index, work,
     extra = dext;
     end = -1;
   }
-  /* initialize opts for loop */
-
-
-  huff = 0;
-  /* starting code */
-
-  sym = 0;
-  /* starting code symbol */
-
-  len = min;
-  /* starting code length */
-
-  next = table_index;
-  /* current table to fill in */
-
-  curr = root;
-  /* current table index bits */
 
-  drop = 0;
-  /* current bits to drop from code for index */
-
-  low = -1;
-  /* trigger new sub-table when len > root */
-
-  used = 1 << root;
-  /* use root table entries */
-
-  mask = used - 1;
-  /* mask for comparing low */
+  /* initialize opts for loop */
+  huff = 0; /* starting code */
+  sym = 0; /* starting code symbol */
+  len = min; /* starting code length */
+  next = table_index; /* current table to fill in */
+  curr = root; /* current table index bits */
+  drop = 0; /* current bits to drop from code for index */
+  low = -1; /* trigger new sub-table when len > root */
+  used = 1 << root; /* use root table entries */
+  mask = used - 1; /* mask for comparing low */
 
   /* check available table space */
-
   if (type === LENS && used > ENOUGH_LENS || type === DISTS && used > ENOUGH_DISTS) {
     return 1;
   }
-  /* process all codes and make table entries */
-
 
+  /* process all codes and make table entries */
   for (;;) {
     /* create table entry */
     here_bits = len - drop;
-
     if (work[sym] < end) {
       here_op = 0;
       here_val = work[sym];
@@ -304,115 +223,90 @@ function inflate_table(type, lens, lens_index, codes, table, table_index, work,
       here_op = extra[extra_index + work[sym]];
       here_val = base[base_index + work[sym]];
     } else {
-      here_op = 32 + 64;
-      /* end of block */
-
+      here_op = 32 + 64; /* end of block */
       here_val = 0;
     }
-    /* replicate for those indices with low len bits equal to huff */
-
 
+    /* replicate for those indices with low len bits equal to huff */
     incr = 1 << len - drop;
     fill = 1 << curr;
-    min = fill;
-    /* save offset to next table */
-
+    min = fill; /* save offset to next table */
     do {
       fill -= incr;
       table[next + (huff >> drop) + fill] = here_bits << 24 | here_op << 16 | here_val | 0;
     } while (fill !== 0);
-    /* backwards increment the len-bit code huff */
-
 
+    /* backwards increment the len-bit code huff */
     incr = 1 << len - 1;
-
     while (huff & incr) {
       incr >>= 1;
     }
-
     if (incr !== 0) {
       huff &= incr - 1;
       huff += incr;
     } else {
       huff = 0;
     }
-    /* go to next symbol, update count, len */
-
 
+    /* go to next symbol, update count, len */
     sym++;
-
     if (--count[len] === 0) {
       if (len === max) {
         break;
       }
-
       len = lens[lens_index + work[sym]];
     }
-    /* create new sub-table if needed */
-
 
+    /* create new sub-table if needed */
     if (len > root && (huff & mask) !== low) {
       /* if first time, transition to sub-tables */
       if (drop === 0) {
         drop = root;
       }
-      /* increment past last table */
 
-
-      next += min;
-      /* here min is 1 << curr */
+      /* increment past last table */
+      next += min; /* here min is 1 << curr */
 
       /* determine length of next table */
-
       curr = len - drop;
       left = 1 << curr;
-
       while (curr + drop < max) {
         left -= count[curr + drop];
-
         if (left <= 0) {
           break;
         }
-
         curr++;
         left <<= 1;
       }
-      /* check for enough space */
-
 
+      /* check for enough space */
       used += 1 << curr;
-
       if (type === LENS && used > ENOUGH_LENS || type === DISTS && used > ENOUGH_DISTS) {
         return 1;
       }
-      /* point entry in root table to sub-table */
-
 
+      /* point entry in root table to sub-table */
       low = huff & mask;
       /*table.op[low] = curr;
       table.bits[low] = root;
       table.val[low] = next - opts.table_index;*/
-
       table[low] = root << 24 | curr << 16 | next - table_index | 0;
     }
   }
+
   /* fill in remaining table entry if code is incomplete (guaranteed to have
    at most one remaining entry, since if the code is incomplete, the
    maximum code length that was allowed to get this far is one bit) */
-
-
   if (huff !== 0) {
     //table.op[next + huff] = 64;            /* invalid code marker */
     //table.bits[next + huff] = len - drop;
     //table.val[next + huff] = 0;
     table[next + huff] = len - drop << 24 | 64 << 16 | 0;
   }
+
   /* set return parameters */
   //opts.table_index += used;
-
-
   opts.bits = root;
   return 0;
 }
-
 ;

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

@@ -6,31 +6,21 @@ Object.defineProperty(exports, "__esModule", {
 exports["default"] = void 0;
 var _default = {
   2: 'need dictionary',
-
   /* Z_NEED_DICT       2  */
   1: 'stream end',
-
   /* Z_STREAM_END      1  */
   0: '',
-
   /* Z_OK              0  */
   '-1': 'file error',
-
   /* Z_ERRNO         (-1) */
   '-2': 'stream error',
-
   /* Z_STREAM_ERROR  (-2) */
   '-3': 'data error',
-
   /* Z_DATA_ERROR    (-3) */
   '-4': 'insufficient memory',
-
   /* Z_MEM_ERROR     (-4) */
   '-5': 'buffer error',
-
   /* Z_BUF_ERROR     (-5) */
-  '-6': 'incompatible version'
-  /* Z_VERSION_ERROR (-6) */
-
+  '-6': 'incompatible version' /* Z_VERSION_ERROR (-6) */
 };
 exports["default"] = _default;