zip-js 0.1.0

data/app/assets/javascripts/zipjs/z-worker.js

@@ -0,0 +1,153 @@
+/* jshint worker:true */
+(function main(global) {
+	"use strict";
+
+	if (global.zWorkerInitialized)
+		throw new Error('z-worker.js should be run only once');
+	global.zWorkerInitialized = true;
+
+	addEventListener("message", function(event) {
+		var message = event.data, type = message.type, sn = message.sn;
+		var handler = handlers[type];
+		if (handler) {
+			try {
+				handler(message);
+			} catch (e) {
+				onError(type, sn, e);
+			}
+		}
+		//for debug
+		//postMessage({type: 'echo', originalType: type, sn: sn});
+	});
+
+	var handlers = {
+		importScripts: doImportScripts,
+		newTask: newTask,
+		append: processData,
+		flush: processData,
+	};
+
+	// deflater/inflater tasks indexed by serial numbers
+	var tasks = {};
+
+	function doImportScripts(msg) {
+		if (msg.scripts && msg.scripts.length > 0)
+			importScripts.apply(undefined, msg.scripts);
+		postMessage({type: 'importScripts'});
+	}
+
+	function newTask(msg) {
+		var CodecClass = global[msg.codecClass];
+		var sn = msg.sn;
+		if (tasks[sn])
+			throw Error('duplicated sn');
+		tasks[sn] =  {
+			codec: new CodecClass(msg.options),
+			crcInput: msg.crcType === 'input',
+			crcOutput: msg.crcType === 'output',
+			crc: new Crc32(),
+		};
+		postMessage({type: 'newTask', sn: sn});
+	}
+
+	// performance may not be supported
+	var now = global.performance ? global.performance.now.bind(global.performance) : Date.now;
+
+	function processData(msg) {
+		var sn = msg.sn, type = msg.type, input = msg.data;
+		var task = tasks[sn];
+		// allow creating codec on first append
+		if (!task && msg.codecClass) {
+			newTask(msg);
+			task = tasks[sn];
+		}
+		var isAppend = type === 'append';
+		var start = now();
+		var output;
+		if (isAppend) {
+			try {
+				output = task.codec.append(input, function onprogress(loaded) {
+					postMessage({type: 'progress', sn: sn, loaded: loaded});
+				});
+			} catch (e) {
+				delete tasks[sn];
+				throw e;
+			}
+		} else {
+			delete tasks[sn];
+			output = task.codec.flush();
+		}
+		var codecTime = now() - start;
+
+		start = now();
+		if (input && task.crcInput)
+			task.crc.append(input);
+		if (output && task.crcOutput)
+			task.crc.append(output);
+		var crcTime = now() - start;
+
+		var rmsg = {type: type, sn: sn, codecTime: codecTime, crcTime: crcTime};
+		var transferables = [];
+		if (output) {
+			rmsg.data = output;
+			transferables.push(output.buffer);
+		}
+		if (!isAppend && (task.crcInput || task.crcOutput))
+			rmsg.crc = task.crc.get();
+		
+		// posting a message with transferables will fail on IE10
+		try {
+			postMessage(rmsg, transferables);
+		} catch(ex) {
+			postMessage(rmsg); // retry without transferables
+		}
+	}
+
+	function onError(type, sn, e) {
+		var msg = {
+			type: type,
+			sn: sn,
+			error: formatError(e)
+		};
+		postMessage(msg);
+	}
+
+	function formatError(e) {
+		return { message: e.message, stack: e.stack };
+	}
+
+	// Crc32 code copied from file zip.js
+	function Crc32() {
+		this.crc = -1;
+	}
+	Crc32.prototype.append = function append(data) {
+		var crc = this.crc | 0, table = this.table;
+		for (var offset = 0, len = data.length | 0; offset < len; offset++)
+			crc = (crc >>> 8) ^ table[(crc ^ data[offset]) & 0xFF];
+		this.crc = crc;
+	};
+	Crc32.prototype.get = function get() {
+		return ~this.crc;
+	};
+	Crc32.prototype.table = (function() {
+		var i, j, t, table = []; // Uint32Array is actually slower than []
+		for (i = 0; i < 256; i++) {
+			t = i;
+			for (j = 0; j < 8; j++)
+				if (t & 1)
+					t = (t >>> 1) ^ 0xEDB88320;
+				else
+					t = t >>> 1;
+			table[i] = t;
+		}
+		return table;
+	})();
+
+	// "no-op" codec
+	function NOOP() {}
+	global.NOOP = NOOP;
+	NOOP.prototype.append = function append(bytes, onprogress) {
+		return bytes;
+	};
+	NOOP.prototype.flush = function flush() {};
+})(this);

data/app/assets/javascripts/zipjs/zip-ext.js

@@ -0,0 +1,242 @@
+/*
+ Copyright (c) 2013 Gildas Lormeau. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+ INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+(function() {
+	"use strict";
+
+	var ERR_HTTP_RANGE = "HTTP Range not supported.";
+
+	var Reader = zip.Reader;
+	var Writer = zip.Writer;
+	
+	var ZipDirectoryEntry;
+
+	var appendABViewSupported;
+	try {
+		appendABViewSupported = new Blob([ new DataView(new ArrayBuffer(0)) ]).size === 0;
+	} catch (e) {
+	}
+
+	function HttpReader(url) {
+		var that = this;
+
+		function getData(callback, onerror) {
+			var request;
+			if (!that.data) {
+				request = new XMLHttpRequest();
+				request.addEventListener("load", function() {
+					if (!that.size)
+						that.size = Number(request.getResponseHeader("Content-Length"));
+					that.data = new Uint8Array(request.response);
+					callback();
+				}, false);
+				request.addEventListener("error", onerror, false);
+				request.open("GET", url);
+				request.responseType = "arraybuffer";
+				request.send();
+			} else
+				callback();
+		}
+
+		function init(callback, onerror) {
+			var request = new XMLHttpRequest();
+			request.addEventListener("load", function() {
+				that.size = Number(request.getResponseHeader("Content-Length"));
+				callback();
+			}, false);
+			request.addEventListener("error", onerror, false);
+			request.open("HEAD", url);
+			request.send();
+		}
+
+		function readUint8Array(index, length, callback, onerror) {
+			getData(function() {
+				callback(new Uint8Array(that.data.subarray(index, index + length)));
+			}, onerror);
+		}
+
+		that.size = 0;
+		that.init = init;
+		that.readUint8Array = readUint8Array;
+	}
+	HttpReader.prototype = new Reader();
+	HttpReader.prototype.constructor = HttpReader;
+
+	function HttpRangeReader(url) {
+		var that = this;
+
+		function init(callback, onerror) {
+			var request = new XMLHttpRequest();
+			request.addEventListener("load", function() {
+				that.size = Number(request.getResponseHeader("Content-Length"));
+				if (request.getResponseHeader("Accept-Ranges") == "bytes")
+					callback();
+				else
+					onerror(ERR_HTTP_RANGE);
+			}, false);
+			request.addEventListener("error", onerror, false);
+			request.open("HEAD", url);
+			request.send();
+		}
+
+		function readArrayBuffer(index, length, callback, onerror) {
+			var request = new XMLHttpRequest();
+			request.open("GET", url);
+			request.responseType = "arraybuffer";
+			request.setRequestHeader("Range", "bytes=" + index + "-" + (index + length - 1));
+			request.addEventListener("load", function() {
+				callback(request.response);
+			}, false);
+			request.addEventListener("error", onerror, false);
+			request.send();
+		}
+
+		function readUint8Array(index, length, callback, onerror) {
+			readArrayBuffer(index, length, function(arraybuffer) {
+				callback(new Uint8Array(arraybuffer));
+			}, onerror);
+		}
+
+		that.size = 0;
+		that.init = init;
+		that.readUint8Array = readUint8Array;
+	}
+	HttpRangeReader.prototype = new Reader();
+	HttpRangeReader.prototype.constructor = HttpRangeReader;
+
+	function ArrayBufferReader(arrayBuffer) {
+		var that = this;
+
+		function init(callback, onerror) {
+			that.size = arrayBuffer.byteLength;
+			callback();
+		}
+
+		function readUint8Array(index, length, callback, onerror) {
+			callback(new Uint8Array(arrayBuffer.slice(index, index + length)));
+		}
+
+		that.size = 0;
+		that.init = init;
+		that.readUint8Array = readUint8Array;
+	}
+	ArrayBufferReader.prototype = new Reader();
+	ArrayBufferReader.prototype.constructor = ArrayBufferReader;
+
+	function ArrayBufferWriter() {
+		var array, that = this;
+
+		function init(callback, onerror) {
+			array = new Uint8Array();
+			callback();
+		}
+
+		function writeUint8Array(arr, callback, onerror) {
+			var tmpArray = new Uint8Array(array.length + arr.length);
+			tmpArray.set(array);
+			tmpArray.set(arr, array.length);
+			array = tmpArray;
+			callback();
+		}
+
+		function getData(callback) {
+			callback(array.buffer);
+		}
+
+		that.init = init;
+		that.writeUint8Array = writeUint8Array;
+		that.getData = getData;
+	}
+	ArrayBufferWriter.prototype = new Writer();
+	ArrayBufferWriter.prototype.constructor = ArrayBufferWriter;
+
+	function FileWriter(fileEntry, contentType) {
+		var writer, that = this;
+
+		function init(callback, onerror) {
+			fileEntry.createWriter(function(fileWriter) {
+				writer = fileWriter;
+				callback();
+			}, onerror);
+		}
+
+		function writeUint8Array(array, callback, onerror) {
+			var blob = new Blob([ appendABViewSupported ? array : array.buffer ], {
+				type : contentType
+			});
+			writer.onwrite = function() {
+				writer.onwrite = null;
+				callback();
+			};
+			writer.onerror = onerror;
+			writer.write(blob);
+		}
+
+		function getData(callback) {
+			fileEntry.file(callback);
+		}
+
+		that.init = init;
+		that.writeUint8Array = writeUint8Array;
+		that.getData = getData;
+	}
+	FileWriter.prototype = new Writer();
+	FileWriter.prototype.constructor = FileWriter;
+
+	zip.FileWriter = FileWriter;
+	zip.HttpReader = HttpReader;
+	zip.HttpRangeReader = HttpRangeReader;
+	zip.ArrayBufferReader = ArrayBufferReader;
+	zip.ArrayBufferWriter = ArrayBufferWriter;
+
+	if (zip.fs) {
+		ZipDirectoryEntry = zip.fs.ZipDirectoryEntry;
+		ZipDirectoryEntry.prototype.addHttpContent = function(name, URL, useRangeHeader) {
+			function addChild(parent, name, params, directory) {
+				if (parent.directory)
+					return directory ? new ZipDirectoryEntry(parent.fs, name, params, parent) : new zip.fs.ZipFileEntry(parent.fs, name, params, parent);
+				else
+					throw "Parent entry is not a directory.";
+			}
+
+			return addChild(this, name, {
+				data : URL,
+				Reader : useRangeHeader ? HttpRangeReader : HttpReader
+			});
+		};
+		ZipDirectoryEntry.prototype.importHttpContent = function(URL, useRangeHeader, onend, onerror) {
+			this.importZip(useRangeHeader ? new HttpRangeReader(URL) : new HttpReader(URL), onend, onerror);
+		};
+		zip.fs.FS.prototype.importHttpContent = function(URL, useRangeHeader, onend, onerror) {
+			this.entries = [];
+			this.root = new ZipDirectoryEntry(this);
+			this.root.importHttpContent(URL, useRangeHeader, onend, onerror);
+		};
+	}
+
+})();

data/app/assets/javascripts/zipjs/zip-fs.js

@@ -0,0 +1,541 @@
+/*
+ Copyright (c) 2013 Gildas Lormeau. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright 
+ notice, this list of conditions and the following disclaimer in 
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+ INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+(function() {
+	"use strict";
+
+	var CHUNK_SIZE = 512 * 1024;
+
+	var TextWriter = zip.TextWriter, //
+	BlobWriter = zip.BlobWriter, //
+	Data64URIWriter = zip.Data64URIWriter, //
+	Reader = zip.Reader, //
+	TextReader = zip.TextReader, //
+	BlobReader = zip.BlobReader, //
+	Data64URIReader = zip.Data64URIReader, //
+	createReader = zip.createReader, //
+	createWriter = zip.createWriter;
+
+	function ZipBlobReader(entry) {
+		var that = this, blobReader;
+
+		function init(callback) {
+			that.size = entry.uncompressedSize;
+			callback();
+		}
+
+		function getData(callback) {
+			if (that.data)
+				callback();
+			else
+				entry.getData(new BlobWriter(), function(data) {
+					that.data = data;
+					blobReader = new BlobReader(data);
+					callback();
+				}, null, that.checkCrc32);
+		}
+
+		function readUint8Array(index, length, callback, onerror) {
+			getData(function() {
+				blobReader.readUint8Array(index, length, callback, onerror);
+			}, onerror);
+		}
+
+		that.size = 0;
+		that.init = init;
+		that.readUint8Array = readUint8Array;
+	}
+	ZipBlobReader.prototype = new Reader();
+	ZipBlobReader.prototype.constructor = ZipBlobReader;
+	ZipBlobReader.prototype.checkCrc32 = false;
+
+	function getTotalSize(entry) {
+		var size = 0;
+
+		function process(entry) {
+			size += entry.uncompressedSize || 0;
+			entry.children.forEach(process);
+		}
+
+		process(entry);
+		return size;
+	}
+
+	function initReaders(entry, onend, onerror) {
+		var index = 0;
+
+		function next() {
+			index++;
+			if (index < entry.children.length)
+				process(entry.children[index]);
+			else
+				onend();
+		}
+
+		function process(child) {
+			if (child.directory)
+				initReaders(child, next, onerror);
+			else {
+				child.reader = new child.Reader(child.data, onerror);
+				child.reader.init(function() {
+					child.uncompressedSize = child.reader.size;
+					next();
+				});
+			}
+		}
+
+		if (entry.children.length)
+			process(entry.children[index]);
+		else
+			onend();
+	}
+
+	function detach(entry) {
+		var children = entry.parent.children;
+		children.forEach(function(child, index) {
+			if (child.id == entry.id)
+				children.splice(index, 1);
+		});
+	}
+
+	function exportZip(zipWriter, entry, onend, onprogress, totalSize) {
+		var currentIndex = 0;
+
+		function process(zipWriter, entry, onend, onprogress, totalSize) {
+			var childIndex = 0;
+
+			function exportChild() {
+				var child = entry.children[childIndex];
+				if (child)
+					zipWriter.add(child.getFullname(), child.reader, function() {
+						currentIndex += child.uncompressedSize || 0;
+						process(zipWriter, child, function() {
+							childIndex++;
+							exportChild();
+						}, onprogress, totalSize);
+					}, function(index) {
+						if (onprogress)
+							onprogress(currentIndex + index, totalSize);
+					}, {
+						directory : child.directory,
+						version : child.zipVersion
+					});
+				else
+					onend();
+			}
+
+			exportChild();
+		}
+
+		process(zipWriter, entry, onend, onprogress, totalSize);
+	}
+
+	function addFileEntry(zipEntry, fileEntry, onend, onerror) {
+		function getChildren(fileEntry, callback) {
+			if (fileEntry.isDirectory)
+				fileEntry.createReader().readEntries(callback);
+			if (fileEntry.isFile)
+				callback([]);
+		}
+
+		function process(zipEntry, fileEntry, onend) {
+			getChildren(fileEntry, function(children) {
+				var childIndex = 0;
+
+				function addChild(child) {
+					function nextChild(childFileEntry) {
+						process(childFileEntry, child, function() {
+							childIndex++;
+							processChild();
+						});
+					}
+
+					if (child.isDirectory)
+						nextChild(zipEntry.addDirectory(child.name));
+					if (child.isFile)
+						child.file(function(file) {
+							var childZipEntry = zipEntry.addBlob(child.name, file);
+							childZipEntry.uncompressedSize = file.size;
+							nextChild(childZipEntry);
+						}, onerror);
+				}
+
+				function processChild() {
+					var child = children[childIndex];
+					if (child)
+						addChild(child);
+					else
+						onend();
+				}
+
+				processChild();
+			});
+		}
+
+		if (fileEntry.isDirectory)
+			process(zipEntry, fileEntry, onend);
+		else
+			fileEntry.file(function(file) {
+				zipEntry.addBlob(fileEntry.name, file);
+				onend();
+			}, onerror);
+	}
+
+	function getFileEntry(fileEntry, entry, onend, onprogress, onerror, totalSize, checkCrc32) {
+		var currentIndex = 0;
+
+		function process(fileEntry, entry, onend, onprogress, onerror, totalSize) {
+			var childIndex = 0;
+
+			function addChild(child) {
+				function nextChild(childFileEntry) {
+					currentIndex += child.uncompressedSize || 0;
+					process(childFileEntry, child, function() {
+						childIndex++;
+						processChild();
+					}, onprogress, onerror, totalSize);
+				}
+
+				if (child.directory)
+					fileEntry.getDirectory(child.name, {
+						create : true
+					}, nextChild, onerror);
+				else
+					fileEntry.getFile(child.name, {
+						create : true
+					}, function(file) {
+						child.getData(new zip.FileWriter(file, zip.getMimeType(child.name)), nextChild, function(index) {
+							if (onprogress)
+								onprogress(currentIndex + index, totalSize);
+						}, checkCrc32);
+					}, onerror);
+			}
+
+			function processChild() {
+				var child = entry.children[childIndex];
+				if (child)
+					addChild(child);
+				else
+					onend();
+			}
+
+			processChild();
+		}
+
+		if (entry.directory)
+			process(fileEntry, entry, onend, onprogress, onerror, totalSize);
+		else
+			entry.getData(new zip.FileWriter(fileEntry, zip.getMimeType(entry.name)), onend, onprogress, checkCrc32);
+	}
+
+	function resetFS(fs) {
+		fs.entries = [];
+		fs.root = new ZipDirectoryEntry(fs);
+	}
+
+	function bufferedCopy(reader, writer, onend, onprogress, onerror) {
+		var chunkIndex = 0;
+
+		function stepCopy() {
+			var index = chunkIndex * CHUNK_SIZE;
+			if (onprogress)
+				onprogress(index, reader.size);
+			if (index < reader.size)
+				reader.readUint8Array(index, Math.min(CHUNK_SIZE, reader.size - index), function(array) {
+					writer.writeUint8Array(new Uint8Array(array), function() {
+						chunkIndex++;
+						stepCopy();
+					});
+				}, onerror);
+			else
+				writer.getData(onend);
+		}
+
+		stepCopy();
+	}
+
+	function addChild(parent, name, params, directory) {
+		if (parent.directory)
+			return directory ? new ZipDirectoryEntry(parent.fs, name, params, parent) : new ZipFileEntry(parent.fs, name, params, parent);
+		else
+			throw "Parent entry is not a directory.";
+	}
+
+	function ZipEntry() {
+	}
+
+	ZipEntry.prototype = {
+		init : function(fs, name, params, parent) {
+			var that = this;
+			if (fs.root && parent && parent.getChildByName(name))
+				throw "Entry filename already exists.";
+			if (!params)
+				params = {};
+			that.fs = fs;
+			that.name = name;
+			that.id = fs.entries.length;
+			that.parent = parent;
+			that.children = [];
+			that.zipVersion = params.zipVersion || 0x14;
+			that.uncompressedSize = 0;
+			fs.entries.push(that);
+			if (parent)
+				that.parent.children.push(that);
+		},
+		getFileEntry : function(fileEntry, onend, onprogress, onerror, checkCrc32) {
+			var that = this;
+			initReaders(that, function() {
+				getFileEntry(fileEntry, that, onend, onprogress, onerror, getTotalSize(that), checkCrc32);
+			}, onerror);
+		},
+		moveTo : function(target) {
+			var that = this;
+			if (target.directory) {
+				if (!target.isDescendantOf(that)) {
+					if (that != target) {
+						if (target.getChildByName(that.name))
+							throw "Entry filename already exists.";
+						detach(that);
+						that.parent = target;
+						target.children.push(that);
+					}
+				} else
+					throw "Entry is a ancestor of target entry.";
+			} else
+				throw "Target entry is not a directory.";
+		},
+		getFullname : function() {
+			var that = this, fullname = that.name, entry = that.parent;
+			while (entry) {
+				fullname = (entry.name ? entry.name + "/" : "") + fullname;
+				entry = entry.parent;
+			}
+			return fullname;
+		},
+		isDescendantOf : function(ancestor) {
+			var entry = this.parent;
+			while (entry && entry.id != ancestor.id)
+				entry = entry.parent;
+			return !!entry;
+		}
+	};
+	ZipEntry.prototype.constructor = ZipEntry;
+
+	var ZipFileEntryProto;
+
+	function ZipFileEntry(fs, name, params, parent) {
+		var that = this;
+		ZipEntry.prototype.init.call(that, fs, name, params, parent);
+		that.Reader = params.Reader;
+		that.Writer = params.Writer;
+		that.data = params.data;
+		if (params.getData) {
+			that.getData = params.getData;
+		}
+	}
+
+	ZipFileEntry.prototype = ZipFileEntryProto = new ZipEntry();
+	ZipFileEntryProto.constructor = ZipFileEntry;
+	ZipFileEntryProto.getData = function(writer, onend, onprogress, onerror) {
+		var that = this;
+		if (!writer || (writer.constructor == that.Writer && that.data))
+			onend(that.data);
+		else {
+			if (!that.reader)
+				that.reader = new that.Reader(that.data, onerror);
+			that.reader.init(function() {
+				writer.init(function() {
+					bufferedCopy(that.reader, writer, onend, onprogress, onerror);
+				}, onerror);
+			});
+		}
+	};
+
+	ZipFileEntryProto.getText = function(onend, onprogress, checkCrc32, encoding) {
+		this.getData(new TextWriter(encoding), onend, onprogress, checkCrc32);
+	};
+	ZipFileEntryProto.getBlob = function(mimeType, onend, onprogress, checkCrc32) {
+		this.getData(new BlobWriter(mimeType), onend, onprogress, checkCrc32);
+	};
+	ZipFileEntryProto.getData64URI = function(mimeType, onend, onprogress, checkCrc32) {
+		this.getData(new Data64URIWriter(mimeType), onend, onprogress, checkCrc32);
+	};
+
+	var ZipDirectoryEntryProto;
+
+	function ZipDirectoryEntry(fs, name, params, parent) {
+		var that = this;
+		ZipEntry.prototype.init.call(that, fs, name, params, parent);
+		that.directory = true;
+	}
+
+	ZipDirectoryEntry.prototype = ZipDirectoryEntryProto = new ZipEntry();
+	ZipDirectoryEntryProto.constructor = ZipDirectoryEntry;
+	ZipDirectoryEntryProto.addDirectory = function(name) {
+		return addChild(this, name, null, true);
+	};
+	ZipDirectoryEntryProto.addText = function(name, text) {
+		return addChild(this, name, {
+			data : text,
+			Reader : TextReader,
+			Writer : TextWriter
+		});
+	};
+	ZipDirectoryEntryProto.addBlob = function(name, blob) {
+		return addChild(this, name, {
+			data : blob,
+			Reader : BlobReader,
+			Writer : BlobWriter
+		});
+	};
+	ZipDirectoryEntryProto.addData64URI = function(name, dataURI) {
+		return addChild(this, name, {
+			data : dataURI,
+			Reader : Data64URIReader,
+			Writer : Data64URIWriter
+		});
+	};
+	ZipDirectoryEntryProto.addFileEntry = function(fileEntry, onend, onerror) {
+		addFileEntry(this, fileEntry, onend, onerror);
+	};
+	ZipDirectoryEntryProto.addData = function(name, params) {
+		return addChild(this, name, params);
+	};
+	ZipDirectoryEntryProto.importBlob = function(blob, onend, onerror) {
+		this.importZip(new BlobReader(blob), onend, onerror);
+	};
+	ZipDirectoryEntryProto.importText = function(text, onend, onerror) {
+		this.importZip(new TextReader(text), onend, onerror);
+	};
+	ZipDirectoryEntryProto.importData64URI = function(dataURI, onend, onerror) {
+		this.importZip(new Data64URIReader(dataURI), onend, onerror);
+	};
+	ZipDirectoryEntryProto.exportBlob = function(onend, onprogress, onerror) {
+		this.exportZip(new BlobWriter("application/zip"), onend, onprogress, onerror);
+	};
+	ZipDirectoryEntryProto.exportText = function(onend, onprogress, onerror) {
+		this.exportZip(new TextWriter(), onend, onprogress, onerror);
+	};
+	ZipDirectoryEntryProto.exportFileEntry = function(fileEntry, onend, onprogress, onerror) {
+		this.exportZip(new zip.FileWriter(fileEntry, "application/zip"), onend, onprogress, onerror);
+	};
+	ZipDirectoryEntryProto.exportData64URI = function(onend, onprogress, onerror) {
+		this.exportZip(new Data64URIWriter("application/zip"), onend, onprogress, onerror);
+	};
+	ZipDirectoryEntryProto.importZip = function(reader, onend, onerror) {
+		var that = this;
+		createReader(reader, function(zipReader) {
+			zipReader.getEntries(function(entries) {
+				entries.forEach(function(entry) {
+					var parent = that, path = entry.filename.split("/"), name = path.pop();
+					path.forEach(function(pathPart) {
+						parent = parent.getChildByName(pathPart) || new ZipDirectoryEntry(that.fs, pathPart, null, parent);
+					});
+					if (!entry.directory)
+						addChild(parent, name, {
+							data : entry,
+							Reader : ZipBlobReader
+						});
+				});
+				onend();
+			});
+		}, onerror);
+	};
+	ZipDirectoryEntryProto.exportZip = function(writer, onend, onprogress, onerror) {
+		var that = this;
+		initReaders(that, function() {
+			createWriter(writer, function(zipWriter) {
+				exportZip(zipWriter, that, function() {
+					zipWriter.close(onend);
+				}, onprogress, getTotalSize(that));
+			}, onerror);
+		}, onerror);
+	};
+	ZipDirectoryEntryProto.getChildByName = function(name) {
+		var childIndex, child, that = this;
+		for (childIndex = 0; childIndex < that.children.length; childIndex++) {
+			child = that.children[childIndex];
+			if (child.name == name)
+				return child;
+		}
+	};
+
+	function FS() {
+		resetFS(this);
+	}
+	FS.prototype = {
+		remove : function(entry) {
+			detach(entry);
+			this.entries[entry.id] = null;
+		},
+		find : function(fullname) {
+			var index, path = fullname.split("/"), node = this.root;
+			for (index = 0; node && index < path.length; index++)
+				node = node.getChildByName(path[index]);
+			return node;
+		},
+		getById : function(id) {
+			return this.entries[id];
+		},
+		importBlob : function(blob, onend, onerror) {
+			resetFS(this);
+			this.root.importBlob(blob, onend, onerror);
+		},
+		importText : function(text, onend, onerror) {
+			resetFS(this);
+			this.root.importText(text, onend, onerror);
+		},
+		importData64URI : function(dataURI, onend, onerror) {
+			resetFS(this);
+			this.root.importData64URI(dataURI, onend, onerror);
+		},
+		exportBlob : function(onend, onprogress, onerror) {
+			this.root.exportBlob(onend, onprogress, onerror);
+		},
+		exportText : function(onend, onprogress, onerror) {
+			this.root.exportText(onend, onprogress, onerror);
+		},
+		exportFileEntry : function(fileEntry, onend, onprogress, onerror) {
+			this.root.exportFileEntry(fileEntry, onend, onprogress, onerror);
+		},
+		exportData64URI : function(onend, onprogress, onerror) {
+			this.root.exportData64URI(onend, onprogress, onerror);
+		}
+	};
+
+	zip.fs = {
+		FS : FS,
+		ZipDirectoryEntry : ZipDirectoryEntry,
+		ZipFileEntry : ZipFileEntry
+	};
+
+	zip.getMimeType = function() {
+		return "application/octet-stream";
+	};
+
+})();