dist rebuild

dist/pako_inflate.js

@@ -1,10 +1,10 @@
 
-/*! pako 2.0.4 https://github.com/nodeca/pako @license (MIT AND Zlib) */
+/*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.pako = {}));
-}(this, (function (exports) { 'use strict';
+})(this, (function (exports) { 'use strict';
 
   // Note: adler32 takes 12% for level 0 and 2% for level 6.
   // It isn't worth it to make additional optimizations as in original.
@@ -134,8 +134,8 @@
   // 3. This notice may not be removed or altered from any source distribution.
 
   // See state defs from inflate.js
-  const BAD$1 = 30;       /* got a data error -- remain here until reset */
-  const TYPE$1 = 12;      /* i: waiting for type bits, including last-flag bit */
+  const BAD$1 = 16209;       /* got a data error -- remain here until reset */
+  const TYPE$1 = 16191;      /* i: waiting for type bits, including last-flag bit */
 
   /*
      Decode literal, length, and distance codes and write out the resulting
@@ -527,13 +527,11 @@
     let mask;              /* mask for low root bits */
     let next;             /* next available space in table */
     let base = null;     /* base value table to use */
-    let base_index = 0;
   //  let shoextra;    /* extra bits table to use */
-    let end;                    /* use base and extra for symbol > end */
+    let match;                  /* use base and extra for symbol >= match */
     const count = new Uint16Array(MAXBITS + 1); //[MAXBITS+1];    /* number of codes of each length */
     const offs = new Uint16Array(MAXBITS + 1); //[MAXBITS+1];     /* offsets in table for each length */
     let extra = null;
-    let extra_index = 0;
 
     let here_bits, here_op, here_val;
 
@@ -668,19 +666,17 @@
     // to avoid deopts in old v8
     if (type === CODES$1) {
       base = extra = work;    /* dummy value--not used */
-      end = 19;
+      match = 20;
 
     } else if (type === LENS$1) {
       base = lbase;
-      base_index -= 257;
       extra = lext;
-      extra_index -= 257;
-      end = 256;
+      match = 257;
 
     } else {                    /* DISTS */
       base = dbase;
       extra = dext;
-      end = -1;
+      match = 0;
     }
 
     /* initialize opts for loop */
@@ -704,13 +700,13 @@
     for (;;) {
       /* create table entry */
       here_bits = len - drop;
-      if (work[sym] < end) {
+      if (work[sym] + 1 < match) {
         here_op = 0;
         here_val = work[sym];
       }
-      else if (work[sym] > end) {
-        here_op = extra[extra_index + work[sym]];
-        here_val = base[base_index + work[sym]];
+      else if (work[sym] >= match) {
+        here_op = extra[work[sym] - match];
+        here_val = base[work[sym] - match];
       }
       else {
         here_op = 32 + 64;         /* end of block */
@@ -909,38 +905,38 @@
   /* ===========================================================================*/
 
 
-  const    HEAD = 1;       /* i: waiting for magic header */
-  const    FLAGS = 2;      /* i: waiting for method and flags (gzip) */
-  const    TIME = 3;       /* i: waiting for modification time (gzip) */
-  const    OS = 4;         /* i: waiting for extra flags and operating system (gzip) */
-  const    EXLEN = 5;      /* i: waiting for extra length (gzip) */
-  const    EXTRA = 6;      /* i: waiting for extra bytes (gzip) */
-  const    NAME = 7;       /* i: waiting for end of file name (gzip) */
-  const    COMMENT = 8;    /* i: waiting for end of comment (gzip) */
-  const    HCRC = 9;       /* i: waiting for header crc (gzip) */
-  const    DICTID = 10;    /* i: waiting for dictionary check value */
-  const    DICT = 11;      /* waiting for inflateSetDictionary() call */
-  const        TYPE = 12;      /* i: waiting for type bits, including last-flag bit */
-  const        TYPEDO = 13;    /* i: same, but skip check to exit inflate on new block */
-  const        STORED = 14;    /* i: waiting for stored size (length and complement) */
-  const        COPY_ = 15;     /* i/o: same as COPY below, but only first time in */
-  const        COPY = 16;      /* i/o: waiting for input or output to copy stored block */
-  const        TABLE = 17;     /* i: waiting for dynamic block table lengths */
-  const        LENLENS = 18;   /* i: waiting for code length code lengths */
-  const        CODELENS = 19;  /* i: waiting for length/lit and distance code lengths */
-  const            LEN_ = 20;      /* i: same as LEN below, but only first time in */
-  const            LEN = 21;       /* i: waiting for length/lit/eob code */
-  const            LENEXT = 22;    /* i: waiting for length extra bits */
-  const            DIST = 23;      /* i: waiting for distance code */
-  const            DISTEXT = 24;   /* i: waiting for distance extra bits */
-  const            MATCH = 25;     /* o: waiting for output space to copy string */
-  const            LIT = 26;       /* o: waiting for output space to write literal */
-  const    CHECK = 27;     /* i: waiting for 32-bit check value */
-  const    LENGTH = 28;    /* i: waiting for 32-bit length (gzip) */
-  const    DONE = 29;      /* finished check, done -- remain here until reset */
-  const    BAD = 30;       /* got a data error -- remain here until reset */
-  const    MEM = 31;       /* got an inflate() memory error -- remain here until reset */
-  const    SYNC = 32;      /* looking for synchronization bytes to restart inflate() */
+  const    HEAD = 16180;       /* i: waiting for magic header */
+  const    FLAGS = 16181;      /* i: waiting for method and flags (gzip) */
+  const    TIME = 16182;       /* i: waiting for modification time (gzip) */
+  const    OS = 16183;         /* i: waiting for extra flags and operating system (gzip) */
+  const    EXLEN = 16184;      /* i: waiting for extra length (gzip) */
+  const    EXTRA = 16185;      /* i: waiting for extra bytes (gzip) */
+  const    NAME = 16186;       /* i: waiting for end of file name (gzip) */
+  const    COMMENT = 16187;    /* i: waiting for end of comment (gzip) */
+  const    HCRC = 16188;       /* i: waiting for header crc (gzip) */
+  const    DICTID = 16189;    /* i: waiting for dictionary check value */
+  const    DICT = 16190;      /* waiting for inflateSetDictionary() call */
+  const        TYPE = 16191;      /* i: waiting for type bits, including last-flag bit */
+  const        TYPEDO = 16192;    /* i: same, but skip check to exit inflate on new block */
+  const        STORED = 16193;    /* i: waiting for stored size (length and complement) */
+  const        COPY_ = 16194;     /* i/o: same as COPY below, but only first time in */
+  const        COPY = 16195;      /* i/o: waiting for input or output to copy stored block */
+  const        TABLE = 16196;     /* i: waiting for dynamic block table lengths */
+  const        LENLENS = 16197;   /* i: waiting for code length code lengths */
+  const        CODELENS = 16198;  /* i: waiting for length/lit and distance code lengths */
+  const            LEN_ = 16199;      /* i: same as LEN below, but only first time in */
+  const            LEN = 16200;       /* i: waiting for length/lit/eob code */
+  const            LENEXT = 16201;    /* i: waiting for length extra bits */
+  const            DIST = 16202;      /* i: waiting for distance code */
+  const            DISTEXT = 16203;   /* i: waiting for distance extra bits */
+  const            MATCH = 16204;     /* o: waiting for output space to copy string */
+  const            LIT = 16205;       /* o: waiting for output space to write literal */
+  const    CHECK = 16206;     /* i: waiting for 32-bit check value */
+  const    LENGTH = 16207;    /* i: waiting for 32-bit length (gzip) */
+  const    DONE = 16208;      /* finished check, done -- remain here until reset */
+  const    BAD = 16209;       /* got a data error -- remain here until reset */
+  const    MEM = 16210;       /* got an inflate() memory error -- remain here until reset */
+  const    SYNC = 16211;      /* looking for synchronization bytes to restart inflate() */
 
   /* ===========================================================================*/
 
@@ -965,11 +961,14 @@
 
 
   function InflateState() {
-    this.mode = 0;             /* current inflate mode */
+    this.strm = null;           /* pointer back to this zlib stream */
+    this.mode = 0;              /* current inflate mode */
     this.last = false;          /* true if processing last block */
-    this.wrap = 0;              /* bit 0 true for zlib, bit 1 true for gzip */
+    this.wrap = 0;              /* bit 0 true for zlib, bit 1 true for gzip,
+                                   bit 2 true to validate check value */
     this.havedict = false;      /* true if dictionary provided */
-    this.flags = 0;             /* gzip header method and flags (0 if zlib) */
+    this.flags = 0;             /* gzip header method and flags (0 if zlib), or
+                                   -1 if raw or no header yet */
     this.dmax = 0;              /* zlib header max distance (INFLATE_STRICT) */
     this.check = 0;             /* protected copy of check value */
     this.total = 0;             /* protected copy of output count */
@@ -1023,9 +1022,23 @@
   }
 
 
+  const inflateStateCheck = (strm) => {
+
+    if (!strm) {
+      return 1;
+    }
+    const state = strm.state;
+    if (!state || state.strm !== strm ||
+      state.mode < HEAD || state.mode > SYNC) {
+      return 1;
+    }
+    return 0;
+  };
+
+
   const inflateResetKeep = (strm) => {
 
-    if (!strm || !strm.state) { return Z_STREAM_ERROR$1; }
+    if (inflateStateCheck(strm)) { return Z_STREAM_ERROR$1; }
     const state = strm.state;
     strm.total_in = strm.total_out = state.total = 0;
     strm.msg = ''; /*Z_NULL*/
@@ -1035,6 +1048,7 @@
     state.mode = HEAD;
     state.last = 0;
     state.havedict = 0;
+    state.flags = -1;
     state.dmax = 32768;
     state.head = null/*Z_NULL*/;
     state.hold = 0;
@@ -1052,7 +1066,7 @@
 
   const inflateReset = (strm) => {
 
-    if (!strm || !strm.state) { return Z_STREAM_ERROR$1; }
+    if (inflateStateCheck(strm)) { return Z_STREAM_ERROR$1; }
     const state = strm.state;
     state.wsize = 0;
     state.whave = 0;
@@ -1066,7 +1080,7 @@
     let wrap;
 
     /* get the state */
-    if (!strm || !strm.state) { return Z_STREAM_ERROR$1; }
+    if (inflateStateCheck(strm)) { return Z_STREAM_ERROR$1; }
     const state = strm.state;
 
     /* extract wrap request from windowBits parameter */
@@ -1075,7 +1089,7 @@
       windowBits = -windowBits;
     }
     else {
-      wrap = (windowBits >> 4) + 1;
+      wrap = (windowBits >> 4) + 5;
       if (windowBits < 48) {
         windowBits &= 15;
       }
@@ -1106,7 +1120,9 @@
     //if (state === Z_NULL) return Z_MEM_ERROR;
     //Tracev((stderr, "inflate: allocated\n"));
     strm.state = state;
+    state.strm = strm;
     state.window = null/*Z_NULL*/;
+    state.mode = HEAD;     /* to pass state test in inflateReset2() */
     const ret = inflateReset2(strm, windowBits);
     if (ret !== Z_OK$1) {
       strm.state = null/*Z_NULL*/;
@@ -1255,7 +1271,7 @@
       new Uint8Array([ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ]);
 
 
-    if (!strm || !strm.state || !strm.output ||
+    if (inflateStateCheck(strm) || !strm.output ||
         (!strm.input && strm.avail_in !== 0)) {
       return Z_STREAM_ERROR$1;
     }
@@ -1296,6 +1312,9 @@
           }
           //===//
           if ((state.wrap & 2) && hold === 0x8b1f) {  /* gzip header */
+            if (state.wbits === 0) {
+              state.wbits = 15;
+            }
             state.check = 0/*crc32(0L, Z_NULL, 0)*/;
             //=== CRC2(state.check, hold);
             hbuf[0] = hold & 0xff;
@@ -1310,7 +1329,6 @@
             state.mode = FLAGS;
             break;
           }
-          state.flags = 0;           /* expect zlib header */
           if (state.head) {
             state.head.done = false;
           }
@@ -1333,7 +1351,7 @@
           if (state.wbits === 0) {
             state.wbits = len;
           }
-          else if (len > state.wbits) {
+          if (len > 15 || len > state.wbits) {
             strm.msg = 'invalid window size';
             state.mode = BAD;
             break;
@@ -1344,6 +1362,7 @@
           state.dmax = 1 << state.wbits;
           //state.dmax = 1 << len;
 
+          state.flags = 0;               /* indicate zlib header */
           //Tracev((stderr, "inflate:   zlib header ok\n"));
           strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
           state.mode = hold & 0x200 ? DICTID : TYPE;
@@ -1375,7 +1394,7 @@
           if (state.head) {
             state.head.text = ((hold >> 8) & 1);
           }
-          if (state.flags & 0x0200) {
+          if ((state.flags & 0x0200) && (state.wrap & 4)) {
             //=== CRC2(state.check, hold);
             hbuf[0] = hold & 0xff;
             hbuf[1] = (hold >>> 8) & 0xff;
@@ -1400,7 +1419,7 @@
           if (state.head) {
             state.head.time = hold;
           }
-          if (state.flags & 0x0200) {
+          if ((state.flags & 0x0200) && (state.wrap & 4)) {
             //=== CRC4(state.check, hold)
             hbuf[0] = hold & 0xff;
             hbuf[1] = (hold >>> 8) & 0xff;
@@ -1428,7 +1447,7 @@
             state.head.xflags = (hold & 0xff);
             state.head.os = (hold >> 8);
           }
-          if (state.flags & 0x0200) {
+          if ((state.flags & 0x0200) && (state.wrap & 4)) {
             //=== CRC2(state.check, hold);
             hbuf[0] = hold & 0xff;
             hbuf[1] = (hold >>> 8) & 0xff;
@@ -1455,7 +1474,7 @@
             if (state.head) {
               state.head.extra_len = hold;
             }
-            if (state.flags & 0x0200) {
+            if ((state.flags & 0x0200) && (state.wrap & 4)) {
               //=== CRC2(state.check, hold);
               hbuf[0] = hold & 0xff;
               hbuf[1] = (hold >>> 8) & 0xff;
@@ -1497,7 +1516,7 @@
                 //        len + copy > state.head.extra_max ?
                 //        state.head.extra_max - len : copy);
               }
-              if (state.flags & 0x0200) {
+              if ((state.flags & 0x0200) && (state.wrap & 4)) {
                 state.check = crc32_1(state.check, input, copy, next);
               }
               have -= copy;
@@ -1523,7 +1542,7 @@
               }
             } while (len && copy < have);
 
-            if (state.flags & 0x0200) {
+            if ((state.flags & 0x0200) && (state.wrap & 4)) {
               state.check = crc32_1(state.check, input, copy, next);
             }
             have -= copy;
@@ -1548,7 +1567,7 @@
                 state.head.comment += String.fromCharCode(len);
               }
             } while (len && copy < have);
-            if (state.flags & 0x0200) {
+            if ((state.flags & 0x0200) && (state.wrap & 4)) {
               state.check = crc32_1(state.check, input, copy, next);
             }
             have -= copy;
@@ -1570,7 +1589,7 @@
               bits += 8;
             }
             //===//
-            if (hold !== (state.check & 0xffff)) {
+            if ((state.wrap & 4) && hold !== (state.check & 0xffff)) {
               strm.msg = 'header crc mismatch';
               state.mode = BAD;
               break;
@@ -2223,15 +2242,15 @@
             _out -= left;
             strm.total_out += _out;
             state.total += _out;
-            if (_out) {
+            if ((state.wrap & 4) && _out) {
               strm.adler = state.check =
-                  /*UPDATE(state.check, put - _out, _out);*/
+                  /*UPDATE_CHECK(state.check, put - _out, _out);*/
                   (state.flags ? crc32_1(state.check, output, _out, put - _out) : adler32_1(state.check, output, _out, put - _out));
 
             }
             _out = left;
             // NB: crc32 stored as signed 32-bit int, zswap32 returns signed too
-            if ((state.flags ? hold : zswap32(hold)) !== state.check) {
+            if ((state.wrap & 4) && (state.flags ? hold : zswap32(hold)) !== state.check) {
               strm.msg = 'incorrect data check';
               state.mode = BAD;
               break;
@@ -2254,7 +2273,7 @@
               bits += 8;
             }
             //===//
-            if (hold !== (state.total & 0xffffffff)) {
+            if ((state.wrap & 4) && hold !== (state.total & 0xffffffff)) {
               strm.msg = 'incorrect length check';
               state.mode = BAD;
               break;
@@ -2309,8 +2328,8 @@
     strm.total_in += _in;
     strm.total_out += _out;
     state.total += _out;
-    if (state.wrap && _out) {
-      strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
+    if ((state.wrap & 4) && _out) {
+      strm.adler = state.check = /*UPDATE_CHECK(state.check, strm.next_out - _out, _out);*/
         (state.flags ? crc32_1(state.check, output, _out, strm.next_out - _out) : adler32_1(state.check, output, _out, strm.next_out - _out));
     }
     strm.data_type = state.bits + (state.last ? 64 : 0) +
@@ -2325,7 +2344,7 @@
 
   const inflateEnd = (strm) => {
 
-    if (!strm || !strm.state /*|| strm->zfree == (free_func)0*/) {
+    if (inflateStateCheck(strm)) {
       return Z_STREAM_ERROR$1;
     }
 
@@ -2341,7 +2360,7 @@
   const inflateGetHeader = (strm, head) => {
 
     /* check state */
-    if (!strm || !strm.state) { return Z_STREAM_ERROR$1; }
+    if (inflateStateCheck(strm)) { return Z_STREAM_ERROR$1; }
     const state = strm.state;
     if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR$1; }
 
@@ -2360,7 +2379,7 @@
     let ret;
 
     /* check state */
-    if (!strm /* == Z_NULL */ || !strm.state /* == Z_NULL */) { return Z_STREAM_ERROR$1; }
+    if (inflateStateCheck(strm)) { return Z_STREAM_ERROR$1; }
     state = strm.state;
 
     if (state.wrap !== 0 && state.mode !== DICT) {
@@ -2401,6 +2420,7 @@
   var inflateInfo = 'pako inflate (from Nodeca project)';
 
   /* Not implemented
+  module.exports.inflateCodesUsed = inflateCodesUsed;
   module.exports.inflateCopy = inflateCopy;
   module.exports.inflateGetDictionary = inflateGetDictionary;
   module.exports.inflateMark = inflateMark;
@@ -2408,6 +2428,7 @@
   module.exports.inflateSync = inflateSync;
   module.exports.inflateSyncPoint = inflateSyncPoint;
   module.exports.inflateUndermine = inflateUndermine;
+  module.exports.inflateValidate = inflateValidate;
   */
 
   var inflate_1$1 = {
@@ -3118,7 +3139,7 @@
 
   /**
    * inflate(data[, options]) -> Uint8Array|String
-   * - data (Uint8Array): input data to decompress.
+   * - data (Uint8Array|ArrayBuffer): input data to decompress.
    * - options (Object): zlib inflate options.
    *
    * Decompress `data` with inflate/ungzip and `options`. Autodetect
@@ -3169,7 +3190,7 @@
 
   /**
    * inflateRaw(data[, options]) -> Uint8Array|String
-   * - data (Uint8Array): input data to decompress.
+   * - data (Uint8Array|ArrayBuffer): input data to decompress.
    * - options (Object): zlib inflate options.
    *
    * The same as [[inflate]], but creates raw data, without wrapper
@@ -3184,7 +3205,7 @@
 
   /**
    * ungzip(data[, options]) -> Uint8Array|String
-   * - data (Uint8Array): input data to decompress.
+   * - data (Uint8Array|ArrayBuffer): input data to decompress.
    * - options (Object): zlib inflate options.
    *
    * Just shortcut to [[inflate]], because it autodetects format
@@ -3208,11 +3229,11 @@
 
   exports.Inflate = Inflate_1;
   exports.constants = constants;
-  exports['default'] = inflate_1;
+  exports["default"] = inflate_1;
   exports.inflate = inflate_2;
   exports.inflateRaw = inflateRaw_1;
   exports.ungzip = ungzip;
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));