const C_i = Components.interfaces;

 const C_r = Components.results;

 const C_c = Components.classes;

 const C_C = Components.Constructor;

 const C_E = Components.Exception;

 function dumpJSStack() {

   dump((new Error).stack + "\n");

 }

 function ERROR_FAILURE() {

   dumpJSStack();

   throw new C_E("Failure", C_r.NS_ERROR_FAILURE);

 }

 function ERROR_ABORT() {

   dumpJSStack();

   throw new C_E("Aborted", C_r.NS_ERROR_ABORT);

 }

 function NOT_AVAILABLE() {

   //dumpJSStack();

   throw new C_E("Not available", C_r.NS_ERROR_NOT_AVAILABLE);

 }

 function ERROR_UNEXPECTED() {

   dumpJSStack();

   throw new C_E("Assertion failure", C_r.NS_ERROR_UNEXPECTED);

 }

 function INVALID_ARG() {

   dumpJSStack();

   throw new C_E("Invalid argument", C_r.NS_ERROR_INVALID_ARG);

 }

 const File = C_C("@mozilla.org/file/local;1",

                  C_i.nsILocalFile,

                  "initWithPath");

 const InputStream = C_C("@mozilla.org/network/file-input-stream;1",

                         C_i.nsIFileInputStream,

                         "init");

 const SInputStream = C_C("@mozilla.org/scriptableinputstream;1",

                          C_i.nsIScriptableInputStream,

                          "init");

 const OutputStream = C_C("@mozilla.org/network/file-output-stream;1",

                          C_i.nsIFileOutputStream,

                          "init");

 var ZipReader = C_C("@mozilla.org/libjar/zip-reader;1",

                     "nsIZipReader",

                     "open");

 function readFromStream(aInputStream) {

   var sInStream = new SInputStream(aInputStream);

   var contents = "";

   try {

     while (sInStream.available()) {

       contents += sInStream.read(sInStream.available());

     }

   } catch (e) {

     dumpJSStack();

     throw e;

   }

   sInStream.close();

   return contents;

 }

 function sortEntries(a, b) {

   if (a.leafName < b.leafName)

     return -1;

   if (b.leafName < a.leafName)

     return +1;

   return 0;

 }

 const ZipTypesMap = /.(zip|jar|xpi)$/;

 function ZipEntryKey(args) {

   this._keySequence = args;

 }

 ZipEntryKey.prototype = {

   equals: function(other) {

     if (other._keySequence.length != this._keySequence.length)

       return false;

     for (var i = 0; i < this._keySequence.length; i++)

       if (this._keySequence[i] != other._keySequence[i])

         return false;

     return true;

   }

 };

 const ZipMap = {

   _data: [

     /* key = ["local file path", "zip path 1", "zip path 2"...]

        value = nsILocalFile for the zip archive.

        We use this to bootstrap in the case of a zip inside a zip (think JAR

        files inside XPI files).  We'll hold a reference to a temporary copy of

        the inner zip file.

     */

   ],

   getZip: function getZip(aKeySequence, aLength) {

     ShutdownObserver.checkShutdown();

     if (aKeySequence.length < 2 || aLength < 2)

       ERROR_UNEXPECTED();

     var keyTeeth = [];

     for (var i = 0; i < aLength; i++)

       keyTeeth[i] = aKeySequence[i];

     var key = new ZipEntryKey(keyTeeth);

     for (i = 0; i < this._data.length; i++)

       if (key.equals(this._data[i].key))

         return this._data.file;

     var temp = C_c["@mozilla.org/file/directory_service;1"]

                   .getService(C_i.nsIProperties)

                   .get("TmpD", C_i.nsIFile).clone();

     temp.append("verbosio");

     temp.append("zip-entries.zip");

     temp.createUnique(C_i.nsIFile.NORMAL_FILE_TYPE, 0666);

     var lastTooth = keyTeeth.pop();

     var parentZip;

     if (keyTeeth.length == 1)

       parentZip = new File(keyTeeth[0]);

     else

       parentZip = this.getZip(keyTeeth, keyTeeth.length).file;

     if (!parentZip)

       ERROR_UNEXPECTED();

     var zipReader = new ZipReader(parentZip);

     zipReader.extract(lastTooth, temp);

     zipReader.close();

     var dataObj = {

       key: key,

       file: temp

     };

     this._data.unshift(dataObj);

     return temp;

   },

   shutdown: function shutdown() {

     for each (var dataObj in this._data) {

       dataObj.file.remove(true);

     }

     this._data = [];

   }

 };

 function FlatFile(aFilePath) {

   ShutdownObserver.checkShutdown();

   this.filePath = aFilePath;

   this.fileObj = new File(aFilePath);

   this.contents = null;

   this.isZip = ZipTypesMap.test(aFilePath);

   this.isDirectory = this.fileObj.isDirectory();

 }

 FlatFile.prototype = {

   exists: function() {

     ShutdownObserver.checkShutdown();

     return this.fileObj.exists();

   },

   get leafName() {

     ShutdownObserver.checkShutdown();

     return this.fileObj.leafName;

   },

   read: function read()

   {

     ShutdownObserver.checkShutdown();

     if (!this.exists())

       ERROR_ABORT();

     if (this.isZip || this.isDirectory)

       ERROR_ABORT();

     var rawInStream = new InputStream(this.fileObj, -1, 0, 0);

     return readFromStream(rawInStream);

   },

   write: function write(contents)

   {

     ShutdownObserver.checkShutdown();

     if (!this.fileObj)

       ERROR_ABORT();

     if (this.isZip || this.isDirectory)

       ERROR_ABORT();

     var outStream = new OutputStream(this.fileObj, -1, -1, 0);

     outStream.write(contents, contents.length);

     outStream.close();

   },

   getDirContents: function() {

     ShutdownObserver.checkShutdown();

     var rv = [];

     if (!this.fileObj)

       ERROR_ABORT();

     if (!this.fileObj.exists())

       ERROR_ABORT();

     if (this.isDirectory)

     {

       var entries = this.fileObj.directoryEntries;

       while (entries.hasMoreElements())

       {

         var fileObj = entries.getNext().QueryInterface(C_i.nsILocalFile);

         rv.push(getFile(fileObj.path));

       }

     }

     else if (this.isZip) {

       var zipReader = new ZipReader(this.fileObj);

       var iterator = zipReader.findEntries("*");

       while (iterator.hasMore()) {

         var entryName = iterator.getNext();

         var slash = entryName.indexOf("/");

         if ((slash == -1) || (slash == entryName.length - 1))

           rv.push(getFile(this.filePath, entryName));

       }

       zipReader.close();

     }

     else {

       NOT_AVAILABLE();

     }

     rv.sort(sortEntries);

     return rv;

   },

   toString: function toString() {

     return "[object FlatFile(" + this.filePath + ")]";

   }

 };

 function ZipFile(aFilePath, aZipPath) {

   ShutdownObserver.checkShutdown();

   this.filePath = aFilePath;

   this.zipPath = aZipPath;

   this.fileObj = new File(aFilePath);

   var zipReader = new ZipReader(this.fileObj);

   this.zipWriter = null;

   this.contents = null;

   this.isZip = ZipTypesMap.test(aZipPath);

   this.isDirectory = zipReader.hasEntry(this.zipPath) ?

                      zipReader.getEntry(this.zipPath).isDirectory :

                      false;

   zipReader.close();

 }

 ZipFile.prototype = {

   exists: function() {

     ShutdownObserver.checkShutdown();

     var zipReader = new ZipReader(this.fileObj);

     var rv = this.fileObj.exists() && zipReader.hasEntry(this.zipPath);

     zipReader.close();

     return rv;

   },

   get leafName() {

     ShutdownObserver.checkShutdown();

     var index = this.zipPath.lastIndexOf("/");

     var str = "";

     if (index == this.zipPath.length - 1)

       str = this.zipPath.substr(this.zipPath, index);

     else

       str = this.zipPath;

     return str.substr(str.lastIndexOf("/") + 1);

   },

   read: function read() {

     ShutdownObserver.checkShutdown();

     if (!this.exists())

       ERROR_ABORT();

     if (this.isZip || this.isDirectory)

       ERROR_ABORT();

     var zipReader = new ZipReader(this.fileObj);

     if (!zipReader.hasEntry(this.zipPath)) {

       zipReader.close();

       ERROR_ABORT();

     }

     var rawInStream = zipReader.getInputStream(this.zipPath);

     var rv = readFromStream(rawInStream);

     zipReader.close();

     return rv;

   },

   write: function write(contents) {

     ShutdownObserver.checkShutdown();

     if (!this.fileObj)

       ERROR_ABORT();

     if (this.isZip || this.isDirectory)

       ERROR_ABORT();

     if (!this.zipWriter) {

       this.zipWriter = C_c["@mozilla.org/zipwriter;1"]

                           .createInstance(C_i.nsIZipWriter);

     }

     this.zipWriter.open(this.fileObj, 0x02 | 0x08 | 0x10);

     var stream = C_c["@mozilla.org/io/string-input-stream;1"]

                     .createInstance(C_i.nsIStringInputStream);

     stream.setData(contents, contents.length);

     this.zipWriter.addEntryStream(this.zipPath, 0, 0, stream, false);

     this.zipWriter.close();

   },

   getDirContents: function() {

     ShutdownObserver.checkShutdown();

     var rv = [];

     if (!this.fileObj)

       ERROR_ABORT();

     if (!this.fileObj.exists())

       ERROR_ABORT();

     var zipReader = new ZipReader(this.fileObj);

     if (!zipReader.hasEntry(this.zipPath)) {

       zipReader.close();

       ERROR_ABORT();

     }

     if (this.isDirectory)

     {

       var path = this.zipPath;

       if (path.charAt(path.length - 1) != "/")

         path += "/";

       var iterator = zipReader.findEntries("*");

       while (iterator.hasMore()) {

         var entryName = iterator.getNext();

         if ((entryName.indexOf(path) != 0) || (entryName == path))

           continue;

         entryName = entryName.substr(path.length);

         var slash = entryName.indexOf("/");

         if ((slash == -1) || (slash == entryName.length - 1))

           rv.push(getFile(this.filePath, path + entryName));

       }

     }

     else if (this.isZip) {

       var paths = [this.filePath, this.zipPath];

       var zip = ZipMap.getZip(paths, paths.length);

       var zipReader = new ZipReader(zip);

       var iterator = zipReader.findEntries("*");

       while (iterator.hasMore()) {

         var entryName = iterator.getNext();

         var slash = entryName.indexOf("/");

         if ((slash == -1) || (slash == entryName.length - 1))

           rv.push(getFile(this.filePath, this.zipPath, entryName));

       }

     }

     else {

       zipReader.close();

       NOT_AVAILABLE();

     }

     zipReader.close();

     return rv.sort(sortEntries);

   },

   toString: function toString() {

     return "[object ZipFile(" + this.filePath + ", " + this.zipPath + ")]";

   }

 };

 function ZipZipFile(aZipArchives, aPaths)

 {

   ShutdownObserver.checkShutdown();

   this.fileObj = aZipArchives[0];

   this.zipArchives = aZipArchives;

   this.paths = aPaths;

   this.finalPath = aPaths[aPaths.length - 1];

   this.lastZipArchive = aZipArchives[aZipArchives.length - 1];

   var zipReader = new ZipReader(this.lastZipArchive);

   this.zipWriter = null;

   this.contents = null;

   this.isZip = ZipTypesMap.test(this.finalPath);

   this.isDirectory = this.exists() &&

                      zipReader.getEntry(this.finalPath).isDirectory;

   zipReader.close();

 }

 ZipZipFile.prototype = {

   exists: function exists() {

     ShutdownObserver.checkShutdown();

     for each (zip in this.zipArchives)

       if (!zip.exists())

         return false;

     var zipReader = new ZipReader(this.lastZipArchive);

     var rv = zipReader.hasEntry(this.finalPath);

     zipReader.close();

     return rv;

   },

   get leafName() {

     ShutdownObserver.checkShutdown();

     var index = this.finalPath.lastIndexOf("/");

     var str = "";

     if (index == this.finalPath.length - 1)

       str = this.finalPath.substr(this.finalPath, index);

     else

       str = this.finalPath;

     return str.substr(str.lastIndexOf("/") + 1);

   },

   read: function read() {

     ShutdownObserver.checkShutdown();

     if (!this.fileObj)

       ERROR_ABORT();

     if (typeof this.exists != "function") {

       ERROR_UNEXPECTED();

     }

     if (!this.exists())

       ERROR_ABORT();

     if (this.isZip || this.isDirectory)

       ERROR_ABORT();

     var zipReader = new ZipReader(this.lastZipArchive);

     if (!zipReader.hasEntry(this.finalPath)) {

       zipReader.close();

       ERROR_ABORT();

     }

     var rawInStream = zipReader.getInputStream(this.finalPath);

     var rv = readFromStream(rawInStream);

     zipReader.close();

     return rv;

   },

   writeStack: function writeStack(i) {

     ShutdownObserver.checkShutdown();

     if (!this.zipWriter)

       ERROR_UNEXPECTED();

     var parentZip = this.zipArchives[i];

     var path = this.paths[i + 1];

     var childZip = this.zipArchives[i + 1];

     this.zipWriter.open(parentZip, 0x02 | 0x08 | 0x10);

     this.zipWriter.addEntryFile(path, 0, childZip, false);

     this.zipWriter.close();

     if (i > 0)

       this.writeStack(i - 1);

   },

   write: function write(contents) {

     ShutdownObserver.checkShutdown();

     if (!this.fileObj)

       ERROR_ABORT();

     if (this.isZip || this.isDirectory)

       ERROR_ABORT();

     var contentWriter;

     var index = this.zipArchives.length - 1;

     if (!this.zipWriter) {

       this.zipWriter = C_c["@mozilla.org/zipwriter;1"]

                           .createInstance(C_i.nsIZipWriter);

     }

     this.zipWriter.open(this.zipArchives[index], 0x02 | 0x08 | 0x10);

     var stream = C_c["@mozilla.org/io/string-input-stream;1"]

                     .createInstance(C_i.nsIStringInputStream);

     stream.setData(contents, contents.length);

     this.zipWriter.addEntryStream(this.finalPath, 0, 0, stream, false);

     this.zipWriter.close();

     this.writeStack(this.zipArchives.length - 2);

   },

   getDirContents: function() {

     ShutdownObserver.checkShutdown();

     var rv = [];

     if (!this.fileObj)

       ERROR_ABORT();

     if (!this.fileObj.exists())

       ERROR_ABORT();

     var zipReader = new ZipReader(this.lastZipArchive);

     if (!zipReader.hasEntry(this.finalPath)) {

       zipReader.close();

       ERROR_ABORT();

     }

     var newPaths = [];

     for (var i = 0; i < this.paths.length; i++)

       newPaths.push(this.paths[i]);

     var path = "";

     if (this.isDirectory) {

       path = this.finalPath;

       if (path.charAt(path.length - 1) != "/")

         path += "/";

     }

     else if (this.isZip) {

       newPaths.push(null); // Force a new generation.

     }

     else {

       zipReader.close();

       NOT_AVAILABLE();

     }

     var iterator = zipReader.findEntries("*");

     while (iterator.hasMore()) {

       var entryName = iterator.getNext();

       if ((entryName.indexOf(path) != 0) || (entryName == path))

         continue;

       entryName = entryName.substr(path.length);

       var slash = entryName.indexOf("/");

       if ((slash == -1) || (slash == entryName.length - 1)) {

         newPaths[newPaths.length - 1] = path + entryName;

         rv.push(getFile.apply(this, newPaths));

       }

     }

     zipReader.close();

     rv.sort(sortEntries);

     return rv;

   },

   toString: function toString() {

     var rv = "[object ZipZipFile(";

     for (var i = 0; i < this.paths.length; i++)

       rv += this.paths[i] + ", ";

     rv = rv.substr(0, rv.length - 2) + ")]";

     return rv;

   }

 };

 const FileCacheMap = {

   _data: [],

   getFile: function getFile(key) {

     ShutdownObserver.checkShutdown();

     for each (var obj in this._data)

       if (key.equals(obj.key))

         return obj.file;

     return null;

   },

   addFile: function addFile(key, file) {

     ShutdownObserver.checkShutdown();

     this._data.push({

       key: key,

       file: file

     });

   },

   shutdown: function() {

     this._data = [];

   }

 };

 function getFile() {

   ShutdownObserver.checkShutdown();

   var key = new ZipEntryKey(arguments);

   var rv = FileCacheMap.getFile(key);

   if (rv)

     return rv;

   switch (arguments.length) {

     case 0:

       INVALID_ARG();

     case 1:

       rv = new FlatFile(arguments[0]);

       break;

     case 2:

       rv = new ZipFile(arguments[0], arguments[1]);

       break;

     default: // 3 or more arguments...

       var zipArchives = [new File(arguments[0])];

       for (var i = 1; i < arguments.length - 1; i++) {

         if (ZipTypesMap.test(arguments[i])) {

           zipArchives.push(ZipMap.getZip(arguments, i + 1));

         } else {

           ERROR.UNEXPECTED();

         }

       }

       rv = new ZipZipFile(zipArchives, arguments);

   }

   FileCacheMap.addFile(key, rv);

   return rv;

 }

 const ShutdownObserver = {

   _shutdown: false,

   checkShutdown: function() {

     if (this._shutdown)

       NOT_AVAILABLE();

   },

   observe: function observe(aSubject, aTopic, aData) {

     ZipMap.shutdown();

     FileCacheMap.shutdown();

     this._shutdown = true;

   },

   init: function() {

     var obs = C_c["@mozilla.org/observer-service;1"]

                  .getService(C_i.nsIObserverService);

     obs.addObserver(this, "xpcom-shutdown", false);

     obs.addObserver(this, "verbosio-filecommon-shutdown", false);

   },

   QueryInterface: function QueryInterface(aIID) {

     if (aIID.equals(C_i.nsIObserver) ||

         aIID.equals(C_i.nsiSupports))

       return this;

     throw C_r.NS_ERROR_NO_INTERFACE;

   }

 }

 ShutdownObserver.init();

 const FileCommon = {

   get getFile() {

     return getFile;

   }

 };

 const EXPORTED_SYMBOLS = ["FileCommon"];