@novnc/novnc 1.3.0 → 1.4.0-beta

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

@@ -4,26 +4,21 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports["default"] = GZheader;
-
 function GZheader() {
   /* true if compressed data believed to be text */
   this.text = 0;
   /* modification time */
-
   this.time = 0;
   /* extra flags (not used when writing a gzip file) */
-
   this.xflags = 0;
   /* operating system */
-
   this.os = 0;
   /* pointer to extra field or Z_NULL if none */
-
   this.extra = null;
   /* extra field length (valid if extra != Z_NULL) */
-
   this.extra_len = 0; // Actually, we don't need it in JS,
   // but leave for few code modifications
+
   //
   // Setup limits is not necessary because in js we should not preallocate memory
   // for inflate use constant limit in 65536 bytes
@@ -31,23 +26,16 @@ function GZheader() {
 
   /* space at extra (only when reading header) */
   // this.extra_max  = 0;
-
   /* pointer to zero-terminated file name or Z_NULL */
-
   this.name = '';
   /* space at name (only when reading header) */
   // this.name_max   = 0;
-
   /* pointer to zero-terminated comment or Z_NULL */
-
   this.comment = '';
   /* space at comment (only when reading header) */
   // this.comm_max   = 0;
-
   /* true if there was or will be a header crc */
-
   this.hcrc = 0;
   /* true when done reading gzip header (not used when writing a gzip file) */
-
   this.done = false;
 }

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

@@ -5,11 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = inflate_fast;
 // See state defs from inflate.js
-var BAD = 30;
-/* got a data error -- remain here until reset */
-
-var TYPE = 12;
-/* i: waiting for type bits, including last-flag bit */
+var BAD = 30; /* got a data error -- remain here until reset */
+var TYPE = 12; /* i: waiting for type bits, including last-flag bit */
 
 /*
    Decode literal, length, and distance codes and write out the resulting
@@ -46,97 +43,49 @@ var TYPE = 12;
       requires strm.avail_out >= 258 for each loop to avoid checking for
       output space.
  */
-
 function inflate_fast(strm, start) {
   var state;
-
-  var _in;
-  /* local strm.input */
-
-
-  var last;
-  /* have enough input while in < last */
-
-  var _out;
-  /* local strm.output */
-
-
-  var beg;
-  /* inflate()'s initial strm.output */
-
-  var end;
-  /* while out < end, enough space available */
+  var _in; /* local strm.input */
+  var last; /* have enough input while in < last */
+  var _out; /* local strm.output */
+  var beg; /* inflate()'s initial strm.output */
+  var end; /* while out < end, enough space available */
   //#ifdef INFLATE_STRICT
-
-  var dmax;
-  /* maximum distance from zlib header */
+  var dmax; /* maximum distance from zlib header */
   //#endif
-
-  var wsize;
-  /* window size or zero if not using window */
-
-  var whave;
-  /* valid bytes in the window */
-
-  var wnext;
-  /* window write index */
+  var wsize; /* window size or zero if not using window */
+  var whave; /* valid bytes in the window */
+  var wnext; /* window write index */
   // Use `s_window` instead `window`, avoid conflict with instrumentation tools
-
-  var s_window;
-  /* allocated sliding window, if wsize != 0 */
-
-  var hold;
-  /* local strm.hold */
-
-  var bits;
-  /* local strm.bits */
-
-  var lcode;
-  /* local strm.lencode */
-
-  var dcode;
-  /* local strm.distcode */
-
-  var lmask;
-  /* mask for first level of length codes */
-
-  var dmask;
-  /* mask for first level of distance codes */
-
-  var here;
-  /* retrieved table entry */
-
-  var op;
-  /* code bits, operation, extra bits, or */
-
+  var s_window; /* allocated sliding window, if wsize != 0 */
+  var hold; /* local strm.hold */
+  var bits; /* local strm.bits */
+  var lcode; /* local strm.lencode */
+  var dcode; /* local strm.distcode */
+  var lmask; /* mask for first level of length codes */
+  var dmask; /* mask for first level of distance codes */
+  var here; /* retrieved table entry */
+  var op; /* code bits, operation, extra bits, or */
   /*  window position, window bytes to copy */
-
-  var len;
-  /* match length, unused bytes */
-
-  var dist;
-  /* match distance */
-
-  var from;
-  /* where to copy match from */
-
+  var len; /* match length, unused bytes */
+  var dist; /* match distance */
+  var from; /* where to copy match from */
   var from_source;
   var input, output; // JS specific, because we have no pointers
 
   /* copy state to local variables */
-
-  state = strm.state; //here = state.here;
-
+  state = strm.state;
+  //here = state.here;
   _in = strm.next_in;
   input = strm.input;
   last = _in + (strm.avail_in - 5);
   _out = strm.next_out;
   output = strm.output;
   beg = _out - (start - strm.avail_out);
-  end = _out + (strm.avail_out - 257); //#ifdef INFLATE_STRICT
-
-  dmax = state.dmax; //#endif
-
+  end = _out + (strm.avail_out - 257);
+  //#ifdef INFLATE_STRICT
+  dmax = state.dmax;
+  //#endif
   wsize = state.wsize;
   whave = state.whave;
   wnext = state.wnext;
@@ -147,6 +96,7 @@ function inflate_fast(strm, start) {
   dcode = state.distcode;
   lmask = (1 << state.lenbits) - 1;
   dmask = (1 << state.distbits) - 1;
+
   /* decode literals and length/distances until end-of-block or not enough
      input data or output space */
 
@@ -157,112 +107,82 @@ function inflate_fast(strm, start) {
       hold += input[_in++] << bits;
       bits += 8;
     }
-
     here = lcode[hold & lmask];
-
     dolen: for (;;) {
       // Goto emulation
-      op = here >>> 24
-      /*here.bits*/
-      ;
+      op = here >>> 24 /*here.bits*/;
       hold >>>= op;
       bits -= op;
-      op = here >>> 16 & 0xff
-      /*here.op*/
-      ;
-
+      op = here >>> 16 & 0xff /*here.op*/;
       if (op === 0) {
         /* literal */
         //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
         //        "inflate:         literal '%c'\n" :
         //        "inflate:         literal 0x%02x\n", here.val));
-        output[_out++] = here & 0xffff
-        /*here.val*/
-        ;
+        output[_out++] = here & 0xffff /*here.val*/;
       } else if (op & 16) {
         /* length base */
-        len = here & 0xffff
-        /*here.val*/
-        ;
-        op &= 15;
-        /* number of extra bits */
-
+        len = here & 0xffff /*here.val*/;
+        op &= 15; /* number of extra bits */
         if (op) {
           if (bits < op) {
             hold += input[_in++] << bits;
             bits += 8;
           }
-
           len += hold & (1 << op) - 1;
           hold >>>= op;
           bits -= op;
-        } //Tracevv((stderr, "inflate:         length %u\n", len));
-
-
+        }
+        //Tracevv((stderr, "inflate:         length %u\n", len));
         if (bits < 15) {
           hold += input[_in++] << bits;
           bits += 8;
           hold += input[_in++] << bits;
           bits += 8;
         }
-
         here = dcode[hold & dmask];
-
         dodist: for (;;) {
           // goto emulation
-          op = here >>> 24
-          /*here.bits*/
-          ;
+          op = here >>> 24 /*here.bits*/;
           hold >>>= op;
           bits -= op;
-          op = here >>> 16 & 0xff
-          /*here.op*/
-          ;
+          op = here >>> 16 & 0xff /*here.op*/;
 
           if (op & 16) {
             /* distance base */
-            dist = here & 0xffff
-            /*here.val*/
-            ;
-            op &= 15;
-            /* number of extra bits */
-
+            dist = here & 0xffff /*here.val*/;
+            op &= 15; /* number of extra bits */
             if (bits < op) {
               hold += input[_in++] << bits;
               bits += 8;
-
               if (bits < op) {
                 hold += input[_in++] << bits;
                 bits += 8;
               }
             }
-
-            dist += hold & (1 << op) - 1; //#ifdef INFLATE_STRICT
-
+            dist += hold & (1 << op) - 1;
+            //#ifdef INFLATE_STRICT
             if (dist > dmax) {
               strm.msg = 'invalid distance too far back';
               state.mode = BAD;
               break top;
-            } //#endif
-
-
+            }
+            //#endif
             hold >>>= op;
-            bits -= op; //Tracevv((stderr, "inflate:         distance %u\n", dist));
-
-            op = _out - beg;
-            /* max distance in output */
-
+            bits -= op;
+            //Tracevv((stderr, "inflate:         distance %u\n", dist));
+            op = _out - beg; /* max distance in output */
             if (dist > op) {
               /* see if copy from window */
-              op = dist - op;
-              /* distance back in window */
-
+              op = dist - op; /* distance back in window */
               if (op > whave) {
                 if (state.sane) {
                   strm.msg = 'invalid distance too far back';
                   state.mode = BAD;
                   break top;
-                } // (!) This block is disabled in zlib defailts,
+                }
+
+                // (!) This block is disabled in zlib defailts,
                 // don't enable it for binary compatibility
                 //#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
                 //                if (len <= op - whave) {
@@ -283,97 +203,71 @@ function inflate_fast(strm, start) {
                 //                  continue top;
                 //                }
                 //#endif
-
               }
 
               from = 0; // window index
-
               from_source = s_window;
-
               if (wnext === 0) {
                 /* very common case */
                 from += wsize - op;
-
                 if (op < len) {
                   /* some from window */
                   len -= op;
-
                   do {
                     output[_out++] = s_window[from++];
                   } while (--op);
-
-                  from = _out - dist;
-                  /* rest from output */
-
+                  from = _out - dist; /* rest from output */
                   from_source = output;
                 }
               } else if (wnext < op) {
                 /* wrap around window */
                 from += wsize + wnext - op;
                 op -= wnext;
-
                 if (op < len) {
                   /* some from end of window */
                   len -= op;
-
                   do {
                     output[_out++] = s_window[from++];
                   } while (--op);
-
                   from = 0;
-
                   if (wnext < len) {
                     /* some from start of window */
                     op = wnext;
                     len -= op;
-
                     do {
                       output[_out++] = s_window[from++];
                     } while (--op);
-
-                    from = _out - dist;
-                    /* rest from output */
-
+                    from = _out - dist; /* rest from output */
                     from_source = output;
                   }
                 }
               } else {
                 /* contiguous in window */
                 from += wnext - op;
-
                 if (op < len) {
                   /* some from window */
                   len -= op;
-
                   do {
                     output[_out++] = s_window[from++];
                   } while (--op);
-
-                  from = _out - dist;
-                  /* rest from output */
-
+                  from = _out - dist; /* rest from output */
                   from_source = output;
                 }
               }
-
               while (len > 2) {
                 output[_out++] = from_source[from++];
                 output[_out++] = from_source[from++];
                 output[_out++] = from_source[from++];
                 len -= 3;
               }
-
               if (len) {
                 output[_out++] = from_source[from++];
-
                 if (len > 1) {
                   output[_out++] = from_source[from++];
                 }
               }
             } else {
-              from = _out - dist;
-              /* copy direct from output */
-
+              from = _out - dist; /* copy direct from output */
               do {
                 /* minimum length is three */
                 output[_out++] = output[from++];
@@ -381,10 +275,8 @@ function inflate_fast(strm, start) {
                 output[_out++] = output[from++];
                 len -= 3;
               } while (len > 2);
-
               if (len) {
                 output[_out++] = output[from++];
-
                 if (len > 1) {
                   output[_out++] = output[from++];
                 }
@@ -392,23 +284,18 @@ function inflate_fast(strm, start) {
             }
           } else if ((op & 64) === 0) {
             /* 2nd level distance code */
-            here = dcode[(here & 0xffff
-            /*here.val*/
-            ) + (hold & (1 << op) - 1)];
+            here = dcode[(here & 0xffff /*here.val*/) + (hold & (1 << op) - 1)];
             continue dodist;
           } else {
             strm.msg = 'invalid distance code';
             state.mode = BAD;
             break top;
           }
-
           break; // need to emulate goto via "continue"
         }
       } else if ((op & 64) === 0) {
         /* 2nd level length code */
-        here = lcode[(here & 0xffff
-        /*here.val*/
-        ) + (hold & (1 << op) - 1)];
+        here = lcode[(here & 0xffff /*here.val*/) + (hold & (1 << op) - 1)];
         continue dolen;
       } else if (op & 32) {
         /* end-of-block */
@@ -420,19 +307,17 @@ function inflate_fast(strm, start) {
         state.mode = BAD;
         break top;
       }
-
       break; // need to emulate goto via "continue"
     }
   } while (_in < last && _out < end);
-  /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
-
 
+  /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
   len = bits >> 3;
   _in -= len;
   bits -= len << 3;
   hold &= (1 << bits) - 1;
-  /* update state and return */
 
+  /* update state and return */
   strm.next_in = _in;
   strm.next_out = _out;
   strm.avail_in = _in < last ? 5 + (last - _in) : 5 - (_in - last);
@@ -441,5 +326,4 @@ function inflate_fast(strm, start) {
   state.bits = bits;
   return;
 }
-
 ;