unzipit 1.4.2 → 2.0.0

package/dist/unzipit-worker.module.js

@@ -1,324 +1,36 @@
-/* unzipit@1.4.2, license MIT */
-function inflate(data, buf) {
-	var u8=Uint8Array;
-	if(data[0]==3 && data[1]==0) return (buf ? buf : new u8(0));
-	var bitsF = _bitsF, bitsE = _bitsE, decodeTiny = _decodeTiny, get17 = _get17;
-	
-	var noBuf = (buf==null);
-	if(noBuf) buf = new u8((data.length>>>2)<<3);
-	
-	var BFINAL=0, BTYPE=0, HLIT=0, HDIST=0, HCLEN=0, ML=0, MD=0; 	
-	var off = 0, pos = 0;
-	var lmap, dmap;
-	
-	while(BFINAL==0) {		
-		BFINAL = bitsF(data, pos  , 1);
-		BTYPE  = bitsF(data, pos+1, 2);  pos+=3;
-		//console.log(BFINAL, BTYPE);
-		
-		if(BTYPE==0) {
-			if((pos&7)!=0) pos+=8-(pos&7);
-			var p8 = (pos>>>3)+4, len = data[p8-4]|(data[p8-3]<<8);  //console.log(len);//bitsF(data, pos, 16), 
-			if(noBuf) buf=_check(buf, off+len);
-			buf.set(new u8(data.buffer, data.byteOffset+p8, len), off);
-			//for(var i=0; i<len; i++) buf[off+i] = data[p8+i];
-			//for(var i=0; i<len; i++) if(buf[off+i] != data[p8+i]) throw "e";
-			pos = ((p8+len)<<3);  off+=len;  continue;
-		}
-		if(noBuf) buf=_check(buf, off+(1<<17));  // really not enough in many cases (but PNG and ZIP provide buffer in advance)
-		if(BTYPE==1) {  lmap = U.flmap;  dmap = U.fdmap;  ML = (1<<9)-1;  MD = (1<<5)-1;   }
-		if(BTYPE==2) {
-			HLIT  = bitsE(data, pos   , 5)+257;  
-			HDIST = bitsE(data, pos+ 5, 5)+  1;  
-			HCLEN = bitsE(data, pos+10, 4)+  4;  pos+=14;
-			for(var i=0; i<38; i+=2) {  U.itree[i]=0;  U.itree[i+1]=0;  }
-			var tl = 1;
-			for(var i=0; i<HCLEN; i++) {  var l=bitsE(data, pos+i*3, 3);  U.itree[(U.ordr[i]<<1)+1] = l;  if(l>tl)tl=l;  }     pos+=3*HCLEN;  //console.log(itree);
-			makeCodes(U.itree, tl);
-			codes2map(U.itree, tl, U.imap);
-			
-			lmap = U.lmap;  dmap = U.dmap;
-			
-			pos = decodeTiny(U.imap, (1<<tl)-1, HLIT+HDIST, data, pos, U.ttree);
-			var mx0 = _copyOut(U.ttree,    0, HLIT , U.ltree);  ML = (1<<mx0)-1;
-			var mx1 = _copyOut(U.ttree, HLIT, HDIST, U.dtree);  MD = (1<<mx1)-1;
-			
-			//var ml = decodeTiny(U.imap, (1<<tl)-1, HLIT , data, pos, U.ltree); ML = (1<<(ml>>>24))-1;  pos+=(ml&0xffffff);
-			makeCodes(U.ltree, mx0);
-			codes2map(U.ltree, mx0, lmap);
-			
-			//var md = decodeTiny(U.imap, (1<<tl)-1, HDIST, data, pos, U.dtree); MD = (1<<(md>>>24))-1;  pos+=(md&0xffffff);
-			makeCodes(U.dtree, mx1);
-			codes2map(U.dtree, mx1, dmap);
-		}
-		//var ooff=off, opos=pos;
-		while(true) {
-			var code = lmap[get17(data, pos) & ML];  pos += code&15;
-			var lit = code>>>4;  //U.lhst[lit]++;  
-			if((lit>>>8)==0) {  buf[off++] = lit;  }
-			else if(lit==256) {  break;  }
-			else {
-				var end = off+lit-254;
-				if(lit>264) { var ebs = U.ldef[lit-257];  end = off + (ebs>>>3) + bitsE(data, pos, ebs&7);  pos += ebs&7;  }
-				//dst[end-off]++;
-				
-				var dcode = dmap[get17(data, pos) & MD];  pos += dcode&15;
-				var dlit = dcode>>>4;
-				var dbs = U.ddef[dlit], dst = (dbs>>>4) + bitsF(data, pos, dbs&15);  pos += dbs&15;
-				
-				//var o0 = off-dst, stp = Math.min(end-off, dst);
-				//if(stp>20) while(off<end) {  buf.copyWithin(off, o0, o0+stp);  off+=stp;  }  else
-				//if(end-dst<=off) buf.copyWithin(off, off-dst, end-dst);  else
-				//if(dst==1) buf.fill(buf[off-1], off, end);  else
-				if(noBuf) buf=_check(buf, off+(1<<17));
-				while(off<end) {  buf[off]=buf[off++-dst];    buf[off]=buf[off++-dst];  buf[off]=buf[off++-dst];  buf[off]=buf[off++-dst];  }   
-				off=end;
-				//while(off!=end) {  buf[off]=buf[off++-dst];  }
-			}
-		}
-		//console.log(off-ooff, (pos-opos)>>>3);
-	}
-	//console.log(dst);
-	//console.log(tlen, dlen, off-tlen+tcnt);
-	return buf.length==off ? buf : buf.slice(0,off);
-}
-function _check(buf, len) {
-	var bl=buf.length;  if(len<=bl) return buf;
-	var nbuf = new Uint8Array(Math.max(bl<<1,len));  nbuf.set(buf,0);
-	//for(var i=0; i<bl; i+=4) {  nbuf[i]=buf[i];  nbuf[i+1]=buf[i+1];  nbuf[i+2]=buf[i+2];  nbuf[i+3]=buf[i+3];  }
-	return nbuf;
-}
-
-function _decodeTiny(lmap, LL, len, data, pos, tree) {
-	var bitsE = _bitsE, get17 = _get17;
-	var i = 0;
-	while(i<len) {
-		var code = lmap[get17(data, pos)&LL];  pos+=code&15;
-		var lit = code>>>4; 
-		if(lit<=15) {  tree[i]=lit;  i++;  }
-		else {
-			var ll = 0, n = 0;
-			if(lit==16) {
-				n = (3  + bitsE(data, pos, 2));  pos += 2;  ll = tree[i-1];
-			}
-			else if(lit==17) {
-				n = (3  + bitsE(data, pos, 3));  pos += 3;
-			}
-			else if(lit==18) {
-				n = (11 + bitsE(data, pos, 7));  pos += 7;
-			}
-			var ni = i+n;
-			while(i<ni) {  tree[i]=ll;  i++; }
-		}
-	}
-	return pos;
-}
-function _copyOut(src, off, len, tree) {
-	var mx=0, i=0, tl=tree.length>>>1;
-	while(i<len) {  var v=src[i+off];  tree[(i<<1)]=0;  tree[(i<<1)+1]=v;  if(v>mx)mx=v;  i++;  }
-	while(i<tl ) {  tree[(i<<1)]=0;  tree[(i<<1)+1]=0;  i++;  }
-	return mx;
-}
-
-function makeCodes(tree, MAX_BITS) {  // code, length
-	var max_code = tree.length;
-	var code, bits, n, i, len;
-	
-	var bl_count = U.bl_count;  for(var i=0; i<=MAX_BITS; i++) bl_count[i]=0;
-	for(i=1; i<max_code; i+=2) bl_count[tree[i]]++;
-	
-	var next_code = U.next_code;	// smallest code for each length
-	
-	code = 0;
-	bl_count[0] = 0;
-	for (bits = 1; bits <= MAX_BITS; bits++) {
-		code = (code + bl_count[bits-1]) << 1;
-		next_code[bits] = code;
-	}
-	
-	for (n = 0; n < max_code; n+=2) {
-		len = tree[n+1];
-		if (len != 0) {
-			tree[n] = next_code[len];
-			next_code[len]++;
-		}
-	}
-}
-function codes2map(tree, MAX_BITS, map) {
-	var max_code = tree.length;
-	var r15 = U.rev15;
-	for(var i=0; i<max_code; i+=2) if(tree[i+1]!=0)  {
-		var lit = i>>1;
-		var cl = tree[i+1], val = (lit<<4)|cl; // :  (0x8000 | (U.of0[lit-257]<<7) | (U.exb[lit-257]<<4) | cl);
-		var rest = (MAX_BITS-cl), i0 = tree[i]<<rest, i1 = i0 + (1<<rest);
-		//tree[i]=r15[i0]>>>(15-MAX_BITS);
-		while(i0!=i1) {
-			var p0 = r15[i0]>>>(15-MAX_BITS);
-			map[p0]=val;  i0++;
-		}
-	}
-}
-function revCodes(tree, MAX_BITS) {
-	var r15 = U.rev15, imb = 15-MAX_BITS;
-	for(var i=0; i<tree.length; i+=2) {  var i0 = (tree[i]<<(MAX_BITS-tree[i+1]));  tree[i] = r15[i0]>>>imb;  }
-}
-
-function _bitsE(dt, pos, length) {  return ((dt[pos>>>3] | (dt[(pos>>>3)+1]<<8)                        )>>>(pos&7))&((1<<length)-1);  }
-function _bitsF(dt, pos, length) {  return ((dt[pos>>>3] | (dt[(pos>>>3)+1]<<8) | (dt[(pos>>>3)+2]<<16))>>>(pos&7))&((1<<length)-1);  }
-/*
-function _get9(dt, pos) {
-	return ((dt[pos>>>3] | (dt[(pos>>>3)+1]<<8))>>>(pos&7))&511;
-} */
-function _get17(dt, pos) {	// return at least 17 meaningful bytes
-	return (dt[pos>>>3] | (dt[(pos>>>3)+1]<<8) | (dt[(pos>>>3)+2]<<16) )>>>(pos&7);
-}
-const U = function(){
-	var u16=Uint16Array, u32=Uint32Array;
-	return {
-		next_code : new u16(16),
-		bl_count  : new u16(16),
-		ordr : [ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ],
-		of0  : [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,999,999,999],
-		exb  : [0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,  4,  5,  5,  5,  5,  0,  0,  0,  0],
-		ldef : new u16(32),
-		df0  : [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, 65535, 65535],
-		dxb  : [0,0,0,0,1,1,2, 2, 3, 3, 4, 4, 5, 5,  6,  6,  7,  7,  8,  8,   9,   9,  10,  10,  11,  11,  12,   12,   13,   13,     0,     0],
-		ddef : new u32(32),
-		flmap: new u16(  512),  fltree: [],
-		fdmap: new u16(   32),  fdtree: [],
-		lmap : new u16(32768),  ltree : [],  ttree:[],
-		dmap : new u16(32768),  dtree : [],
-		imap : new u16(  512),  itree : [],
-		//rev9 : new u16(  512)
-		rev15: new u16(1<<15),
-		lhst : new u32(286), dhst : new u32( 30), ihst : new u32(19),
-		lits : new u32(15000),
-		strt : new u16(1<<16),
-		prev : new u16(1<<15)
-	};  
-} ();
-
-(function(){	
-	var len = 1<<15;
-	for(var i=0; i<len; i++) {
-		var x = i;
-		x = (((x & 0xaaaaaaaa) >>> 1) | ((x & 0x55555555) << 1));
-		x = (((x & 0xcccccccc) >>> 2) | ((x & 0x33333333) << 2));
-		x = (((x & 0xf0f0f0f0) >>> 4) | ((x & 0x0f0f0f0f) << 4));
-		x = (((x & 0xff00ff00) >>> 8) | ((x & 0x00ff00ff) << 8));
-		U.rev15[i] = (((x >>> 16) | (x << 16)))>>>17;
-	}
-	
-	function pushV(tgt, n, sv) {  while(n--!=0) tgt.push(0,sv);  }
-	
-	for(var i=0; i<32; i++) {  U.ldef[i]=(U.of0[i]<<3)|U.exb[i];  U.ddef[i]=(U.df0[i]<<4)|U.dxb[i];  }
-	
-	pushV(U.fltree, 144, 8);  pushV(U.fltree, 255-143, 9);  pushV(U.fltree, 279-255, 7);  pushV(U.fltree,287-279,8);
-	/*
-	var i = 0;
-	for(; i<=143; i++) U.fltree.push(0,8);
-	for(; i<=255; i++) U.fltree.push(0,9);
-	for(; i<=279; i++) U.fltree.push(0,7);
-	for(; i<=287; i++) U.fltree.push(0,8);
-	*/
-	makeCodes(U.fltree, 9);
-	codes2map(U.fltree, 9, U.flmap);
-	revCodes (U.fltree, 9);
-	
-	pushV(U.fdtree,32,5);
-	//for(i=0;i<32; i++) U.fdtree.push(0,5);
-	makeCodes(U.fdtree, 5);
-	codes2map(U.fdtree, 5, U.fdmap);
-	revCodes (U.fdtree, 5);
-	
-	pushV(U.itree,19,0);  pushV(U.ltree,286,0);  pushV(U.dtree,30,0);  pushV(U.ttree,320,0);
-	/*
-	for(var i=0; i< 19; i++) U.itree.push(0,0);
-	for(var i=0; i<286; i++) U.ltree.push(0,0);
-	for(var i=0; i< 30; i++) U.dtree.push(0,0);
-	for(var i=0; i<320; i++) U.ttree.push(0,0);
-	*/
-})();
-
-const crc = {
-	table : ( function() {
-	   var tab = new Uint32Array(256);
-	   for (var n=0; n<256; n++) {
-			var c = n;
-			for (var k=0; k<8; k++) {
-				if (c & 1)  c = 0xedb88320 ^ (c >>> 1);
-				else        c = c >>> 1;
-			}
-			tab[n] = c;  }    
-		return tab;  })(),
-	update : function(c, buf, off, len) {
-		for (var i=0; i<len; i++)  c = crc.table[(c ^ buf[off+i]) & 0xff] ^ (c >>> 8);
-		return c;
-	},
-	crc : function(b,o,l)  {  return crc.update(0xffffffff,b,o,l) ^ 0xffffffff;  }
-};
-
-function inflateRaw(file, buf) {  return inflate(file, buf);  }
-
-/* global SharedArrayBuffer, process */
-
+/* unzipit@2.0.0, license MIT */
+var _a, _b;
 function readBlobAsArrayBuffer(blob) {
-  if (blob.arrayBuffer) {
-    return blob.arrayBuffer();
-  }
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.addEventListener('loadend', () => {
-      resolve(reader.result);
+    if (blob.arrayBuffer) {
+        return blob.arrayBuffer();
+    }
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.addEventListener('loadend', () => {
+            resolve(reader.result);
+        });
+        reader.addEventListener('error', reject);
+        reader.readAsArrayBuffer(blob);
     });
-    reader.addEventListener('error', reject);
-    reader.readAsArrayBuffer(blob);
-  });
 }
-
 async function readBlobAsUint8Array(blob) {
-  const arrayBuffer = await readBlobAsArrayBuffer(blob);
-  return new Uint8Array(arrayBuffer);
+    const arrayBuffer = await readBlobAsArrayBuffer(blob);
+    return new Uint8Array(arrayBuffer);
 }
-
 function isBlob(v) {
-  return typeof Blob !== 'undefined' && v instanceof Blob;
+    return typeof Blob !== 'undefined' && v instanceof Blob;
 }
+const isNode = (typeof process !== 'undefined') &&
+    !!(process === null || process === void 0 ? void 0 : process.versions) &&
+    (typeof ((_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) !== 'undefined') &&
+    (typeof ((_b = process === null || process === void 0 ? void 0 : process.versions) === null || _b === void 0 ? void 0 : _b.electron) === 'undefined');
 
-const isNode =
-    (typeof process !== 'undefined') &&
-    process.versions &&
-    (typeof process.versions.node !== 'undefined') &&
-    (typeof process.versions.electron === 'undefined');
-
-/* global require */
-
+/* global DecompressionStream */
 // note: we only handle the inflate portion in a worker
 // every other part is already async and JavaScript
 // is non blocking. I suppose if you had a million entry
 // zip file then the loop going through the directory
 // might take time but that's an unlikely situation.
-
-const msgHelper = (function() {
-  if (isNode) {
-    const { parentPort } = require('worker_threads');
-
-    return {
-      postMessage: parentPort.postMessage.bind(parentPort),
-      addEventListener: parentPort.on.bind(parentPort),
-    };
-  } else {
-    return {
-      postMessage: self.postMessage.bind(self),
-      addEventListener(type, fn) {
-        self.addEventListener(type, (e) => {
-          fn(e.data);
-        });
-      },
-    };
-  }
-}());
-
 // class InflateRequest {
 //   id: string,
 //   src: ArrayBuffer, SharedArrayBuffer, blob
@@ -330,53 +42,77 @@ const msgHelper = (function() {
 // then 50 blobs will be asked to be read at once.
 // If feels like that should happen at a higher level (user code)
 // or a lower level (the browser)?
-async function inflate$1(req) {
-  const {id, src, uncompressedSize, type} = req;
-  try {
-    let srcData;
-    if (isBlob(src)) {
-      srcData = await readBlobAsUint8Array(src);
-    } else {
-      srcData = new Uint8Array(src);
+async function decompressRaw(src) {
+    const ds = new DecompressionStream('deflate-raw');
+    const writer = ds.writable.getWriter();
+    writer.write(src).then(() => writer.close()).catch(() => { });
+    const chunks = [];
+    const reader = ds.readable.getReader();
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        chunks.push(value);
+    }
+    const size = chunks.reduce((s, c) => s + c.byteLength, 0);
+    const result = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return result;
+}
+async function inflate(req, postMessage) {
+    const { id, src, type } = req;
+    try {
+        const srcData = isBlob(src)
+            ? await readBlobAsUint8Array(src)
+            : new Uint8Array(src);
+        const dstData = await decompressRaw(srcData);
+        const transferables = [];
+        let data;
+        if (type) {
+            data = new Blob([dstData], { type });
+        }
+        else {
+            data = dstData.buffer;
+            transferables.push(data);
+        }
+        postMessage({ id, data }, transferables);
     }
-    const dstData = new Uint8Array(uncompressedSize);
-    inflateRaw(srcData, dstData);
-    const transferables = [];
-    let data;
-    if (type) {
-      data = new Blob([dstData], {type});
-    } else {
-      data = dstData.buffer;
-      transferables.push(data);
+    catch (e) {
+        console.error(e);
+        postMessage({ id, error: `${e}` });
     }
-    msgHelper.postMessage({
-      id,
-      data,
-    }, transferables);
-  } catch (e) {
-    console.error(e);
-    msgHelper.postMessage({
-      id,
-      error: `${e.toString()}`,
+}
+function handleMessage(msg, postMessage) {
+    const { type, data } = msg;
+    if (type === 'inflate') {
+        inflate(data, postMessage);
+    }
+    else {
+        throw new Error('no handler for type: ' + type);
+    }
+}
+if (isNode) {
+    // Use dynamic import so this works in both CJS and ESM contexts.
+    // The import of a built-in resolves before any messages can arrive.
+    import('worker_threads').then(({ parentPort }) => {
+        parentPort.on('message', (msg) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            handleMessage(msg, (m, t) => parentPort.postMessage(m, t));
+        });
     });
-  }
 }
-
-const handlers = {
-  inflate: inflate$1,
-};
-
-msgHelper.addEventListener('message', function(e) {
-  const {type, data} = e;
-  const fn = handlers[type];
-  if (!fn) {
-    throw new Error('no handler for type: ' + type);
-  }
-  fn(data);
-});
-
-if (!isNode) {
-  // needed for firefox AFAICT as there so no other
-  // way to know a worker loaded successfully.?
-  msgHelper.postMessage('start');
+else {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const workerSelf = self;
+    workerSelf.addEventListener('message', (e) => {
+        handleMessage(e.data, (m, t) => workerSelf.postMessage(m, t));
+    });
+    // needed for firefox AFAICT as there is no other
+    // way to know a worker loaded successfully.
+    workerSelf.postMessage('start');
 }

package/dist/unzipit.d.ts

@@ -1,57 +1,74 @@
-export type ZipInfo = {
-  zip: Zip,
-  entries: {[key: string]: ZipEntry},
-};
-
-export type ZipInfoRaw = {
-  zip: Zip,
-  entries: ZipEntry[],
-};
-
-export type Zip = {
-  comment: string,           // the comment for the zip file
-  commentBytes: Uint8Array,  // the raw data for comment, see nameBytes
-};
-
-export type ZipEntry = {
-  blob(type?: string): Promise<Blob>,  // returns a Blob for this entry
-                                       //  (optional type as in 'image/jpeg')
-  arrayBuffer(): Promise<ArrayBuffer>, // returns an ArrayBuffer for this entry
-  text(): Promise<string>,             // returns text, assumes the text is valid utf8.
-                                    // If you want more options decode arrayBuffer yourself
-  json(): Promise<any>,                // returns text with JSON.parse called on it.
-                                    // If you want more options decode arrayBuffer yourself
-  name: string,                     // name of entry
-  nameBytes: Uint8Array,            // raw name of entry (see notes)
-  size: number,                     // size in bytes
-  compressedSize: number,           // size before decompressing
-  comment: string,                  // the comment for this entry
-  commentBytes: Uint8Array,         // the raw comment for this entry
-  lastModDate: Date,                // a Date
-  isDirectory: boolean,             // True if directory
-  encrypted: boolean,               // True if encrypted
-  externalFileAttributes: number,   // platform specific file attributes
-  versionMadeBy: number,            // platform that made this file
-};
-
-export interface Reader {
-  getLength(): Promise<number>,
-  read(offset: number, size: number): Promise<Uint8Array>,
+import ArrayBufferReader from './ArrayBufferReader.js';
+import BlobReader from './BlobReader.js';
+export { ArrayBufferReader, BlobReader };
+export * from './HTTPRangeReader.js';
+export type { Reader } from './BlobReader.js';
+export type { UnzipitOptions } from './inflate.js';
+import type { Reader } from './BlobReader.js';
+export interface Zip {
+    comment: string;
+    commentBytes: Uint8Array;
+}
+export interface ZipInfoRaw {
+    zip: Zip;
+    entries: ZipEntry[];
+}
+export interface ZipInfo {
+    zip: Zip;
+    entries: {
+        [key: string]: ZipEntry;
+    };
 }
-
-export type UnzipitOptions = {
-  useWorkers?: boolean;
-  workerURL?: string;
-  numWorkers?: number;
-};
-
 export type TypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array;
-
-export class HTTPRangeReader {
-	constructor(url: string);
+interface ExtraField {
+    id: number;
+    data: Uint8Array;
+}
+interface RawEntry {
+    versionMadeBy: number;
+    versionNeededToExtract: number;
+    generalPurposeBitFlag: number;
+    compressionMethod: number;
+    lastModFileTime: number;
+    lastModFileDate: number;
+    crc32: number;
+    compressedSize: number;
+    uncompressedSize: number;
+    fileNameLength: number;
+    extraFieldLength: number;
+    fileCommentLength: number;
+    internalFileAttributes: number;
+    externalFileAttributes: number;
+    relativeOffsetOfLocalHeader: number;
+    nameBytes: Uint8Array;
+    name: string;
+    extraFields: ExtraField[];
+    commentBytes: Uint8Array;
+    comment: string;
+    fileName?: string;
+}
+export declare class ZipEntry {
+    private _reader;
+    private _rawEntry;
+    name: string;
+    nameBytes: Uint8Array;
+    size: number;
+    compressedSize: number;
+    comment: string;
+    commentBytes: Uint8Array;
+    compressionMethod: number;
+    lastModDate: Date;
+    isDirectory: boolean;
+    encrypted: boolean;
+    externalFileAttributes: number;
+    versionMadeBy: number;
+    constructor(reader: Reader, rawEntry: RawEntry);
+    blob(type?: string): Promise<Blob>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    text(): Promise<string>;
+    json(): Promise<any>;
 }
-
-export function unzip(src: string | ArrayBuffer | TypedArray | Blob | Reader): Promise<ZipInfo>;
-export function unzipRaw(src: string | ArrayBuffer | TypedArray | Blob | Reader): Promise<ZipInfoRaw>;
-export function setOptions(options: UnzipitOptions): void;
-export function cleanup(): void;
+export declare function setOptions(options: import('./inflate').UnzipitOptions): void;
+export declare function unzipRaw(source: string | ArrayBuffer | TypedArray | SharedArrayBuffer | Blob | Reader): Promise<ZipInfoRaw>;
+export declare function unzip(source: string | ArrayBuffer | TypedArray | SharedArrayBuffer | Blob | Reader): Promise<ZipInfo>;
+export declare function cleanup(): void;