refactor: move brother_node development artifact to dev/test-nodes subdirectory

Development Artifact Cleanup:
✅ BROTHER_NODE REORGANIZATION: Moved development test node to appropriate location
- dev/test-nodes/brother_node/: Moved from root directory for better organization
- Contains development configuration, test logs, and test chain data
- No impact on production systems - purely development/testing artifact

✅ DEVELOPMENT ARTIFACTS IDENTIFIED:
- Chain ID: aitbc-brother-chain (test/development chain)
- Ports: 8010 (P2P) and 8011 (RPC) - different from production
- Environment: .env file with test configuration
- Logs: rpc.log and node.log from development testing session (March 15, 2026)

✅ ROOT DIRECTORY CLEANUP: Removed development clutter from production directory
- brother_node/ moved to dev/test-nodes/brother_node/
- Root directory now contains only production-ready components
- Development artifacts properly organized in dev/ subdirectory

DIRECTORY STRUCTURE IMPROVEMENT:
📁 dev/test-nodes/: Development and testing node configurations
🏗️ Root Directory: Clean production structure with only essential components
🧪 Development Isolation: Test environments separated from production

BENEFITS:
✅ Clean Production Directory: No development artifacts in root
✅ Better Organization: Development nodes grouped in dev/ subdirectory
✅ Clear Separation: Production vs development environments clearly distinguished
✅ Maintainability: Easier to identify and manage development components

RESULT: Successfully moved brother_node development artifact to dev/test-nodes/ subdirectory, cleaning up the root directory while preserving development testing environment for future use.

dev/env/node_modules/adm-zip/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2012 Another-D-Mention Software and other contributors, 
+http://www.another-d-mention.ro/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

dev/env/node_modules/adm-zip/README.md

@@ -0,0 +1,65 @@
+# ADM-ZIP for NodeJS with added support for electron original-fs
+
+ADM-ZIP is a pure JavaScript implementation for zip data compression for [NodeJS](https://nodejs.org/). 
+
+# Installation
+
+With [npm](https://www.npmjs.com/) do:
+
+    $ npm install adm-zip
+
+## What is it good for?
+The library allows you to:
+
+* decompress zip files directly to disk or in memory buffers
+* compress files and store them to disk in .zip format or in compressed buffers
+* update content of/add new/delete files from an existing .zip
+
+# Dependencies
+There are no other nodeJS libraries that ADM-ZIP is dependent of
+
+# Examples
+
+## Basic usage
+```javascript
+
+	var AdmZip = require('adm-zip');
+
+	// reading archives
+	var zip = new AdmZip("./my_file.zip");
+	var zipEntries = zip.getEntries(); // an array of ZipEntry records
+
+	zipEntries.forEach(function(zipEntry) {
+	    console.log(zipEntry.toString()); // outputs zip entries information
+		if (zipEntry.entryName == "my_file.txt") {
+		     console.log(zipEntry.getData().toString('utf8')); 
+		}
+	});
+	// outputs the content of some_folder/my_file.txt
+	console.log(zip.readAsText("some_folder/my_file.txt")); 
+	// extracts the specified file to the specified location
+	zip.extractEntryTo(/*entry name*/"some_folder/my_file.txt", /*target path*/"/home/me/tempfolder", /*maintainEntryPath*/false, /*overwrite*/true);
+	// extracts everything
+	zip.extractAllTo(/*target path*/"/home/me/zipcontent/", /*overwrite*/true);
+	
+	
+	// creating archives
+	var zip = new AdmZip();
+	
+	// add file directly
+	var content = "inner content of the file";
+	zip.addFile("test.txt", Buffer.alloc(content.length, content), "entry comment goes here");
+	// add local file
+	zip.addLocalFile("/home/me/some_picture.png");
+	// get everything as a buffer
+	var willSendthis = zip.toBuffer();
+	// or write everything to disk
+	zip.writeZip(/*target file name*/"/home/me/files.zip");
+	
+	
+	// ... more examples in the wiki
+```
+
+For more detailed information please check out the [wiki](https://github.com/cthackers/adm-zip/wiki).
+
+[![Build Status](https://travis-ci.org/cthackers/adm-zip.svg?branch=master)](https://travis-ci.org/cthackers/adm-zip)

dev/env/node_modules/adm-zip/adm-zip.js

@@ -0,0 +1,639 @@
+var Utils = require("./util");
+var fs = Utils.FileSystem.require(),
+	pth = require("path");
+
+fs.existsSync = fs.existsSync || pth.existsSync;
+
+var ZipEntry = require("./zipEntry"),
+	ZipFile = require("./zipFile");
+
+var isWin = /^win/.test(process.platform);
+
+
+module.exports = function (/**String*/input) {
+	var _zip = undefined,
+		_filename = "";
+
+	if (input && typeof input === "string") { // load zip file
+		if (fs.existsSync(input)) {
+			_filename = input;
+			_zip = new ZipFile(input, Utils.Constants.FILE);
+		} else {
+			throw new Error(Utils.Errors.INVALID_FILENAME);
+		}
+	} else if (input && Buffer.isBuffer(input)) { // load buffer
+		_zip = new ZipFile(input, Utils.Constants.BUFFER);
+	} else { // create new zip file
+		_zip = new ZipFile(null, Utils.Constants.NONE);
+	}
+
+	function sanitize(prefix, name) {
+		prefix = pth.resolve(pth.normalize(prefix));
+		var parts = name.split('/');
+		for (var i = 0, l = parts.length; i < l; i++) {
+			var path = pth.normalize(pth.join(prefix, parts.slice(i, l).join(pth.sep)));
+			if (path.indexOf(prefix) === 0) {
+				return path;
+			}
+		}
+		return pth.normalize(pth.join(prefix, pth.basename(name)));
+	}
+
+	function getEntry(/**Object*/entry) {
+		if (entry && _zip) {
+			var item;
+			// If entry was given as a file name
+			if (typeof entry === "string")
+				item = _zip.getEntry(entry);
+			// if entry was given as a ZipEntry object
+			if (typeof entry === "object" && typeof entry.entryName !== "undefined" && typeof entry.header !== "undefined")
+				item = _zip.getEntry(entry.entryName);
+
+			if (item) {
+				return item;
+			}
+		}
+		return null;
+	}
+
+	return {
+		/**
+		 * Extracts the given entry from the archive and returns the content as a Buffer object
+		 * @param entry ZipEntry object or String with the full path of the entry
+		 *
+		 * @return Buffer or Null in case of error
+		 */
+		readFile: function (/**Object*/entry) {
+			var item = getEntry(entry);
+			return item && item.getData() || null;
+		},
+
+		/**
+		 * Asynchronous readFile
+		 * @param entry ZipEntry object or String with the full path of the entry
+		 * @param callback
+		 *
+		 * @return Buffer or Null in case of error
+		 */
+		readFileAsync: function (/**Object*/entry, /**Function*/callback) {
+			var item = getEntry(entry);
+			if (item) {
+				item.getDataAsync(callback);
+			} else {
+				callback(null, "getEntry failed for:" + entry)
+			}
+		},
+
+		/**
+		 * Extracts the given entry from the archive and returns the content as plain text in the given encoding
+		 * @param entry ZipEntry object or String with the full path of the entry
+		 * @param encoding Optional. If no encoding is specified utf8 is used
+		 *
+		 * @return String
+		 */
+		readAsText: function (/**Object*/entry, /**String=*/encoding) {
+			var item = getEntry(entry);
+			if (item) {
+				var data = item.getData();
+				if (data && data.length) {
+					return data.toString(encoding || "utf8");
+				}
+			}
+			return "";
+		},
+
+		/**
+		 * Asynchronous readAsText
+		 * @param entry ZipEntry object or String with the full path of the entry
+		 * @param callback
+		 * @param encoding Optional. If no encoding is specified utf8 is used
+		 *
+		 * @return String
+		 */
+		readAsTextAsync: function (/**Object*/entry, /**Function*/callback, /**String=*/encoding) {
+			var item = getEntry(entry);
+			if (item) {
+				item.getDataAsync(function (data, err) {
+					if (err) {
+						callback(data, err);
+						return;
+					}
+
+					if (data && data.length) {
+						callback(data.toString(encoding || "utf8"));
+					} else {
+						callback("");
+					}
+				})
+			} else {
+				callback("");
+			}
+		},
+
+		/**
+		 * Remove the entry from the file or the entry and all it's nested directories and files if the given entry is a directory
+		 *
+		 * @param entry
+		 */
+		deleteFile: function (/**Object*/entry) { // @TODO: test deleteFile
+			var item = getEntry(entry);
+			if (item) {
+				_zip.deleteEntry(item.entryName);
+			}
+		},
+
+		/**
+		 * Adds a comment to the zip. The zip must be rewritten after adding the comment.
+		 *
+		 * @param comment
+		 */
+		addZipComment: function (/**String*/comment) { // @TODO: test addZipComment
+			_zip.comment = comment;
+		},
+
+		/**
+		 * Returns the zip comment
+		 *
+		 * @return String
+		 */
+		getZipComment: function () {
+			return _zip.comment || '';
+		},
+
+		/**
+		 * Adds a comment to a specified zipEntry. The zip must be rewritten after adding the comment
+		 * The comment cannot exceed 65535 characters in length
+		 *
+		 * @param entry
+		 * @param comment
+		 */
+		addZipEntryComment: function (/**Object*/entry, /**String*/comment) {
+			var item = getEntry(entry);
+			if (item) {
+				item.comment = comment;
+			}
+		},
+
+		/**
+		 * Returns the comment of the specified entry
+		 *
+		 * @param entry
+		 * @return String
+		 */
+		getZipEntryComment: function (/**Object*/entry) {
+			var item = getEntry(entry);
+			if (item) {
+				return item.comment || '';
+			}
+			return ''
+		},
+
+		/**
+		 * Updates the content of an existing entry inside the archive. The zip must be rewritten after updating the content
+		 *
+		 * @param entry
+		 * @param content
+		 */
+		updateFile: function (/**Object*/entry, /**Buffer*/content) {
+			var item = getEntry(entry);
+			if (item) {
+				item.setData(content);
+			}
+		},
+
+		/**
+		 * Adds a file from the disk to the archive
+		 *
+		 * @param localPath File to add to zip
+		 * @param zipPath Optional path inside the zip
+		 * @param zipName Optional name for the file
+		 */
+		addLocalFile: function (/**String*/localPath, /**String=*/zipPath, /**String=*/zipName) {
+			if (fs.existsSync(localPath)) {
+				if (zipPath) {
+					zipPath = zipPath.split("\\").join("/");
+					if (zipPath.charAt(zipPath.length - 1) !== "/") {
+						zipPath += "/";
+					}
+				} else {
+					zipPath = "";
+				}
+				var p = localPath.split("\\").join("/").split("/").pop();
+
+				if (zipName) {
+					this.addFile(zipPath + zipName, fs.readFileSync(localPath), "", 0)
+				} else {
+					this.addFile(zipPath + p, fs.readFileSync(localPath), "", 0)
+				}
+			} else {
+				throw new Error(Utils.Errors.FILE_NOT_FOUND.replace("%s", localPath));
+			}
+		},
+
+		/**
+		 * Adds a local directory and all its nested files and directories to the archive
+		 *
+		 * @param localPath
+		 * @param zipPath optional path inside zip
+		 * @param filter optional RegExp or Function if files match will
+		 *               be included.
+		 */
+		addLocalFolder: function (/**String*/localPath, /**String=*/zipPath, /**=RegExp|Function*/filter) {
+			if (filter === undefined) {
+				filter = function () {
+					return true;
+				};
+			} else if (filter instanceof RegExp) {
+				filter = function (filter) {
+					return function (filename) {
+						return filter.test(filename);
+					}
+				}(filter);
+			}
+
+			if (zipPath) {
+				zipPath = zipPath.split("\\").join("/");
+				if (zipPath.charAt(zipPath.length - 1) !== "/") {
+					zipPath += "/";
+				}
+			} else {
+				zipPath = "";
+			}
+			// normalize the path first
+			localPath = pth.normalize(localPath);
+			localPath = localPath.split("\\").join("/"); //windows fix
+			if (localPath.charAt(localPath.length - 1) !== "/")
+				localPath += "/";
+
+			if (fs.existsSync(localPath)) {
+
+				var items = Utils.findFiles(localPath),
+					self = this;
+
+				if (items.length) {
+					items.forEach(function (path) {
+						var p = path.split("\\").join("/").replace(new RegExp(localPath.replace(/(\(|\)|\$)/g, '\\$1'), 'i'), ""); //windows fix
+						if (filter(p)) {
+							if (p.charAt(p.length - 1) !== "/") {
+								self.addFile(zipPath + p, fs.readFileSync(path), "", 0)
+							} else {
+								self.addFile(zipPath + p, Buffer.alloc(0), "", 0)
+							}
+						}
+					});
+				}
+			} else {
+				throw new Error(Utils.Errors.FILE_NOT_FOUND.replace("%s", localPath));
+			}
+		},
+
+		/**
+		 * Asynchronous addLocalFile
+		 * @param localPath
+		 * @param callback
+		 * @param zipPath optional path inside zip
+		 * @param filter optional RegExp or Function if files match will
+		 *               be included.
+		 */
+		addLocalFolderAsync: function (/*String*/localPath, /*Function*/callback, /*String*/zipPath, /*RegExp|Function*/filter) {
+			if (filter === undefined) {
+				filter = function () {
+					return true;
+				};
+			} else if (filter instanceof RegExp) {
+				filter = function (filter) {
+					return function (filename) {
+						return filter.test(filename);
+					}
+				}(filter);
+			}
+
+			if (zipPath) {
+				zipPath = zipPath.split("\\").join("/");
+				if (zipPath.charAt(zipPath.length - 1) !== "/") {
+					zipPath += "/";
+				}
+			} else {
+				zipPath = "";
+			}
+			// normalize the path first
+			localPath = pth.normalize(localPath);
+			localPath = localPath.split("\\").join("/"); //windows fix
+			if (localPath.charAt(localPath.length - 1) !== "/")
+				localPath += "/";
+
+			var self = this;
+			fs.open(localPath, 'r', function (err, fd) {
+				if (err && err.code === 'ENOENT') {
+					callback(undefined, Utils.Errors.FILE_NOT_FOUND.replace("%s", localPath));
+				} else if (err) {
+					callback(undefined, err);
+				} else {
+					var items = Utils.findFiles(localPath);
+					var i = -1;
+
+					var next = function () {
+						i += 1;
+						if (i < items.length) {
+							var p = items[i].split("\\").join("/").replace(new RegExp(localPath.replace(/(\(|\))/g, '\\$1'), 'i'), ""); //windows fix
+							p = p.normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[^\x20-\x7E]/g, '') // accent fix
+							if (filter(p)) {
+								if (p.charAt(p.length - 1) !== "/") {
+									fs.readFile(items[i], function (err, data) {
+										if (err) {
+											callback(undefined, err);
+										} else {
+											self.addFile(zipPath + p, data, '', 0);
+											next();
+										}
+									})
+								} else {
+									self.addFile(zipPath + p, Buffer.alloc(0), "", 0);
+									next();
+								}
+							} else {
+								next();
+							}
+
+						} else {
+							callback(true, undefined);
+						}
+					}
+
+					next();
+				}
+			});
+		},
+
+		/**
+		 * Allows you to create a entry (file or directory) in the zip file.
+		 * If you want to create a directory the entryName must end in / and a null buffer should be provided.
+		 * Comment and attributes are optional
+		 *
+		 * @param entryName
+		 * @param content
+		 * @param comment
+		 * @param attr
+		 */
+		addFile: function (/**String*/entryName, /**Buffer*/content, /**String*/comment, /**Number*/attr) {
+			var entry = new ZipEntry();
+			entry.entryName = entryName;
+			entry.comment = comment || "";
+
+			if (!attr) {
+				if (entry.isDirectory) {
+					attr = (0o40755 << 16) | 0x10; // (permissions drwxr-xr-x) + (MS-DOS directory flag)
+				} else {
+					attr = 0o644 << 16; // permissions -r-wr--r--
+				}
+			}
+
+			entry.attr = attr;
+
+			entry.setData(content);
+			_zip.setEntry(entry);
+		},
+
+		/**
+		 * Returns an array of ZipEntry objects representing the files and folders inside the archive
+		 *
+		 * @return Array
+		 */
+		getEntries: function () {
+			if (_zip) {
+				return _zip.entries;
+			} else {
+				return [];
+			}
+		},
+
+		/**
+		 * Returns a ZipEntry object representing the file or folder specified by ``name``.
+		 *
+		 * @param name
+		 * @return ZipEntry
+		 */
+		getEntry: function (/**String*/name) {
+			return getEntry(name);
+		},
+
+		getEntryCount: function() {
+			return _zip.getEntryCount();
+		},
+
+		forEach: function(callback) {
+			return _zip.forEach(callback);
+		},
+
+		/**
+		 * Extracts the given entry to the given targetPath
+		 * If the entry is a directory inside the archive, the entire directory and it's subdirectories will be extracted
+		 *
+		 * @param entry ZipEntry object or String with the full path of the entry
+		 * @param targetPath Target folder where to write the file
+		 * @param maintainEntryPath If maintainEntryPath is true and the entry is inside a folder, the entry folder
+		 *                          will be created in targetPath as well. Default is TRUE
+		 * @param overwrite If the file already exists at the target path, the file will be overwriten if this is true.
+		 *                  Default is FALSE
+		 *
+		 * @return Boolean
+		 */
+		extractEntryTo: function (/**Object*/entry, /**String*/targetPath, /**Boolean*/maintainEntryPath, /**Boolean*/overwrite) {
+			overwrite = overwrite || false;
+			maintainEntryPath = typeof maintainEntryPath === "undefined" ? true : maintainEntryPath;
+
+			var item = getEntry(entry);
+			if (!item) {
+				throw new Error(Utils.Errors.NO_ENTRY);
+			}
+
+			var entryName = item.entryName;
+
+			var target = sanitize(targetPath, maintainEntryPath ? entryName : pth.basename(entryName));
+
+			if (item.isDirectory) {
+				target = pth.resolve(target, "..");
+				var children = _zip.getEntryChildren(item);
+				children.forEach(function (child) {
+					if (child.isDirectory) return;
+					var content = child.getData();
+					if (!content) {
+						throw new Error(Utils.Errors.CANT_EXTRACT_FILE);
+					}
+					var childName = sanitize(targetPath, maintainEntryPath ? child.entryName : pth.basename(child.entryName));
+
+					Utils.writeFileTo(childName, content, overwrite);
+				});
+				return true;
+			}
+
+			var content = item.getData();
+			if (!content) throw new Error(Utils.Errors.CANT_EXTRACT_FILE);
+
+			if (fs.existsSync(target) && !overwrite) {
+				throw new Error(Utils.Errors.CANT_OVERRIDE);
+			}
+			Utils.writeFileTo(target, content, overwrite);
+
+			return true;
+		},
+
+		/**
+		 * Test the archive
+		 *
+		 */
+		test: function () {
+			if (!_zip) {
+				return false;
+			}
+
+			for (var entry in _zip.entries) {
+				try {
+					if (entry.isDirectory) {
+						continue;
+					}
+					var content = _zip.entries[entry].getData();
+					if (!content) {
+						return false;
+					}
+				} catch (err) {
+					return false;
+				}
+			}
+			return true;
+		},
+
+		/**
+		 * Extracts the entire archive to the given location
+		 *
+		 * @param targetPath Target location
+		 * @param overwrite If the file already exists at the target path, the file will be overwriten if this is true.
+		 *                  Default is FALSE
+		 */
+		extractAllTo: function (/**String*/targetPath, /**Boolean*/overwrite) {
+			overwrite = overwrite || false;
+			if (!_zip) {
+				throw new Error(Utils.Errors.NO_ZIP);
+			}
+			_zip.entries.forEach(function (entry) {
+				var entryName = sanitize(targetPath, entry.entryName.toString());
+				if (entry.isDirectory) {
+					Utils.makeDir(entryName);
+					return;
+				}
+				var content = entry.getData();
+				if (!content) {
+					throw new Error(Utils.Errors.CANT_EXTRACT_FILE);
+				}
+				Utils.writeFileTo(entryName, content, overwrite);
+				try {
+					fs.utimesSync(entryName, entry.header.time, entry.header.time)
+				} catch (err) {
+					throw new Error(Utils.Errors.CANT_EXTRACT_FILE);
+				}
+			})
+		},
+
+		/**
+		 * Asynchronous extractAllTo
+		 *
+		 * @param targetPath Target location
+		 * @param overwrite If the file already exists at the target path, the file will be overwriten if this is true.
+		 *                  Default is FALSE
+		 * @param callback
+		 */
+		extractAllToAsync: function (/**String*/targetPath, /**Boolean*/overwrite, /**Function*/callback) {
+			if (!callback) {
+				callback = function() {}
+			}
+			overwrite = overwrite || false;
+			if (!_zip) {
+				callback(new Error(Utils.Errors.NO_ZIP));
+				return;
+			}
+
+			var entries = _zip.entries;
+			var i = entries.length;
+			entries.forEach(function (entry) {
+				if (i <= 0) return; // Had an error already
+
+				var entryName = pth.normalize(entry.entryName.toString());
+
+				if (entry.isDirectory) {
+					Utils.makeDir(sanitize(targetPath, entryName));
+					if (--i === 0)
+						callback(undefined);
+					return;
+				}
+				entry.getDataAsync(function (content, err) {
+					if (i <= 0) return;
+					if (err) {
+						callback(new Error(err));
+						return;
+					}
+					if (!content) {
+						i = 0;
+						callback(new Error(Utils.Errors.CANT_EXTRACT_FILE));
+						return;
+					}
+
+					Utils.writeFileToAsync(sanitize(targetPath, entryName), content, overwrite, function (succ) {
+						try {
+							fs.utimesSync(pth.resolve(targetPath, entryName), entry.header.time, entry.header.time);
+						} catch (err) {
+							callback(new Error('Unable to set utimes'));
+						}
+						if (i <= 0) return;
+						if (!succ) {
+							i = 0;
+							callback(new Error('Unable to write'));
+							return;
+						}
+						if (--i === 0)
+							callback(undefined);
+					});
+				});
+			})
+		},
+
+		/**
+		 * Writes the newly created zip file to disk at the specified location or if a zip was opened and no ``targetFileName`` is provided, it will overwrite the opened zip
+		 *
+		 * @param targetFileName
+		 * @param callback
+		 */
+		writeZip: function (/**String*/targetFileName, /**Function*/callback) {
+			if (arguments.length === 1) {
+				if (typeof targetFileName === "function") {
+					callback = targetFileName;
+					targetFileName = "";
+				}
+			}
+
+			if (!targetFileName && _filename) {
+				targetFileName = _filename;
+			}
+			if (!targetFileName) return;
+
+			var zipData = _zip.compressToBuffer();
+			if (zipData) {
+				var ok = Utils.writeFileTo(targetFileName, zipData, true);
+				if (typeof callback === 'function') callback(!ok ? new Error("failed") : null, "");
+			}
+		},
+
+		/**
+		 * Returns the content of the entire zip file as a Buffer object
+		 *
+		 * @return Buffer
+		 */
+		toBuffer: function (/**Function=*/onSuccess, /**Function=*/onFail, /**Function=*/onItemStart, /**Function=*/onItemEnd) {
+			this.valueOf = 2;
+			if (typeof onSuccess === "function") {
+				_zip.toAsyncBuffer(onSuccess, onFail, onItemStart, onItemEnd);
+				return null;
+			}
+			return _zip.compressToBuffer()
+		}
+	}
+};

dev/env/node_modules/adm-zip/headers/entryHeader.js

@@ -0,0 +1,261 @@
+var Utils = require("../util"),
+    Constants = Utils.Constants;
+
+/* The central directory file header */
+module.exports = function () {
+    var _verMade = 0x0A,
+        _version = 0x0A,
+        _flags = 0,
+        _method = 0,
+        _time = 0,
+        _crc = 0,
+        _compressedSize = 0,
+        _size = 0,
+        _fnameLen = 0,
+        _extraLen = 0,
+
+        _comLen = 0,
+        _diskStart = 0,
+        _inattr = 0,
+        _attr = 0,
+        _offset = 0;
+
+    var _dataHeader = {};
+
+    function setTime(val) {
+        val = new Date(val);
+        _time = (val.getFullYear() - 1980 & 0x7f) << 25  // b09-16 years from 1980
+            | (val.getMonth() + 1) << 21                 // b05-08 month
+            | val.getDate() << 16                        // b00-04 hour
+
+            // 2 bytes time
+            | val.getHours() << 11    // b11-15 hour
+            | val.getMinutes() << 5   // b05-10 minute
+            | val.getSeconds() >> 1;  // b00-04 seconds divided by 2
+    }
+
+    setTime(+new Date());
+
+    return {
+        get made () { return _verMade; },
+        set made (val) { _verMade = val; },
+
+        get version () { return _version; },
+        set version (val) { _version = val },
+
+        get flags () { return _flags },
+        set flags (val) { _flags = val; },
+
+        get method () { return _method; },
+        set method (val) { _method = val; },
+
+        get time () { return new Date(
+            ((_time >> 25) & 0x7f) + 1980,
+            ((_time >> 21) & 0x0f) - 1,
+            (_time >> 16) & 0x1f,
+            (_time >> 11) & 0x1f,
+            (_time >> 5) & 0x3f,
+            (_time & 0x1f) << 1
+        );
+        },
+        set time (val) {
+            setTime(val);
+        },
+
+        get crc () { return _crc; },
+        set crc (val) { _crc = val; },
+
+        get compressedSize () { return _compressedSize; },
+        set compressedSize (val) { _compressedSize = val; },
+
+        get size () { return _size; },
+        set size (val) { _size = val; },
+
+        get fileNameLength () { return _fnameLen; },
+        set fileNameLength (val) { _fnameLen = val; },
+
+        get extraLength () { return _extraLen },
+        set extraLength (val) { _extraLen = val; },
+
+        get commentLength () { return _comLen },
+        set commentLength (val) { _comLen = val },
+
+        get diskNumStart () { return _diskStart },
+        set diskNumStart (val) { _diskStart = val },
+
+        get inAttr () { return _inattr },
+        set inAttr (val) { _inattr = val },
+
+        get attr () { return _attr },
+        set attr (val) { _attr = val },
+
+        get offset () { return _offset },
+        set offset (val) { _offset = val },
+
+        get encripted () { return (_flags & 1) === 1 },
+
+        get entryHeaderSize () {
+            return Constants.CENHDR + _fnameLen + _extraLen + _comLen;
+        },
+
+        get realDataOffset () {
+            return _offset + Constants.LOCHDR + _dataHeader.fnameLen + _dataHeader.extraLen;
+        },
+
+        get dataHeader () {
+            return _dataHeader;
+        },
+
+        loadDataHeaderFromBinary : function(/*Buffer*/input) {
+            var data = input.slice(_offset, _offset + Constants.LOCHDR);
+            // 30 bytes and should start with "PK\003\004"
+            if (data.readUInt32LE(0) !== Constants.LOCSIG) {
+                throw new Error(Utils.Errors.INVALID_LOC);
+            }
+            _dataHeader = {
+                // version needed to extract
+                version : data.readUInt16LE(Constants.LOCVER),
+                // general purpose bit flag
+                flags : data.readUInt16LE(Constants.LOCFLG),
+                // compression method
+                method : data.readUInt16LE(Constants.LOCHOW),
+                // modification time (2 bytes time, 2 bytes date)
+                time : data.readUInt32LE(Constants.LOCTIM),
+                // uncompressed file crc-32 value
+                crc : data.readUInt32LE(Constants.LOCCRC),
+                // compressed size
+                compressedSize : data.readUInt32LE(Constants.LOCSIZ),
+                // uncompressed size
+                size : data.readUInt32LE(Constants.LOCLEN),
+                // filename length
+                fnameLen : data.readUInt16LE(Constants.LOCNAM),
+                // extra field length
+                extraLen : data.readUInt16LE(Constants.LOCEXT)
+            }
+        },
+
+        loadFromBinary : function(/*Buffer*/data) {
+            // data should be 46 bytes and start with "PK 01 02"
+            if (data.length !== Constants.CENHDR || data.readUInt32LE(0) !== Constants.CENSIG) {
+                throw new Error(Utils.Errors.INVALID_CEN);
+            }
+            // version made by
+            _verMade = data.readUInt16LE(Constants.CENVEM);
+            // version needed to extract
+            _version = data.readUInt16LE(Constants.CENVER);
+            // encrypt, decrypt flags
+            _flags = data.readUInt16LE(Constants.CENFLG);
+            // compression method
+            _method = data.readUInt16LE(Constants.CENHOW);
+            // modification time (2 bytes time, 2 bytes date)
+            _time = data.readUInt32LE(Constants.CENTIM);
+            // uncompressed file crc-32 value
+            _crc = data.readUInt32LE(Constants.CENCRC);
+            // compressed size
+            _compressedSize = data.readUInt32LE(Constants.CENSIZ);
+            // uncompressed size
+            _size = data.readUInt32LE(Constants.CENLEN);
+            // filename length
+            _fnameLen = data.readUInt16LE(Constants.CENNAM);
+            // extra field length
+            _extraLen = data.readUInt16LE(Constants.CENEXT);
+            // file comment length
+            _comLen = data.readUInt16LE(Constants.CENCOM);
+            // volume number start
+            _diskStart = data.readUInt16LE(Constants.CENDSK);
+            // internal file attributes
+            _inattr = data.readUInt16LE(Constants.CENATT);
+            // external file attributes
+            _attr = data.readUInt32LE(Constants.CENATX);
+            // LOC header offset
+            _offset = data.readUInt32LE(Constants.CENOFF);
+        },
+
+        dataHeaderToBinary : function() {
+            // LOC header size (30 bytes)
+            var data = Buffer.alloc(Constants.LOCHDR);
+            // "PK\003\004"
+            data.writeUInt32LE(Constants.LOCSIG, 0);
+            // version needed to extract
+            data.writeUInt16LE(_version, Constants.LOCVER);
+            // general purpose bit flag
+            data.writeUInt16LE(_flags, Constants.LOCFLG);
+            // compression method
+            data.writeUInt16LE(_method, Constants.LOCHOW);
+            // modification time (2 bytes time, 2 bytes date)
+            data.writeUInt32LE(_time, Constants.LOCTIM);
+            // uncompressed file crc-32 value
+            data.writeUInt32LE(_crc, Constants.LOCCRC);
+            // compressed size
+            data.writeUInt32LE(_compressedSize, Constants.LOCSIZ);
+            // uncompressed size
+            data.writeUInt32LE(_size, Constants.LOCLEN);
+            // filename length
+            data.writeUInt16LE(_fnameLen, Constants.LOCNAM);
+            // extra field length
+            data.writeUInt16LE(_extraLen, Constants.LOCEXT);
+            return data;
+        },
+
+        entryHeaderToBinary : function() {
+            // CEN header size (46 bytes)
+            var data = Buffer.alloc(Constants.CENHDR + _fnameLen + _extraLen + _comLen);
+            // "PK\001\002"
+            data.writeUInt32LE(Constants.CENSIG, 0);
+            // version made by
+            data.writeUInt16LE(_verMade, Constants.CENVEM);
+            // version needed to extract
+            data.writeUInt16LE(_version, Constants.CENVER);
+            // encrypt, decrypt flags
+            data.writeUInt16LE(_flags, Constants.CENFLG);
+            // compression method
+            data.writeUInt16LE(_method, Constants.CENHOW);
+            // modification time (2 bytes time, 2 bytes date)
+            data.writeUInt32LE(_time, Constants.CENTIM);
+            // uncompressed file crc-32 value
+            data.writeUInt32LE(_crc, Constants.CENCRC);
+            // compressed size
+            data.writeUInt32LE(_compressedSize, Constants.CENSIZ);
+            // uncompressed size
+            data.writeUInt32LE(_size, Constants.CENLEN);
+            // filename length
+            data.writeUInt16LE(_fnameLen, Constants.CENNAM);
+            // extra field length
+            data.writeUInt16LE(_extraLen, Constants.CENEXT);
+            // file comment length
+            data.writeUInt16LE(_comLen, Constants.CENCOM);
+            // volume number start
+            data.writeUInt16LE(_diskStart, Constants.CENDSK);
+            // internal file attributes
+            data.writeUInt16LE(_inattr, Constants.CENATT);
+            // external file attributes
+            data.writeUInt32LE(_attr, Constants.CENATX);
+            // LOC header offset
+            data.writeUInt32LE(_offset, Constants.CENOFF);
+            // fill all with
+            data.fill(0x00, Constants.CENHDR);
+            return data;
+        },
+
+        toString : function() {
+            return '{\n' +
+                '\t"made" : ' + _verMade + ",\n" +
+                '\t"version" : ' + _version + ",\n" +
+                '\t"flags" : ' + _flags + ",\n" +
+                '\t"method" : ' + Utils.methodToString(_method) + ",\n" +
+                '\t"time" : ' + this.time + ",\n" +
+                '\t"crc" : 0x' + _crc.toString(16).toUpperCase() + ",\n" +
+                '\t"compressedSize" : ' + _compressedSize + " bytes,\n" +
+                '\t"size" : ' + _size + " bytes,\n" +
+                '\t"fileNameLength" : ' + _fnameLen + ",\n" +
+                '\t"extraLength" : ' + _extraLen + " bytes,\n" +
+                '\t"commentLength" : ' + _comLen + " bytes,\n" +
+                '\t"diskNumStart" : ' + _diskStart + ",\n" +
+                '\t"inAttr" : ' + _inattr + ",\n" +
+                '\t"attr" : ' + _attr + ",\n" +
+                '\t"offset" : ' + _offset + ",\n" +
+                '\t"entryHeaderSize" : ' + (Constants.CENHDR + _fnameLen + _extraLen + _comLen) + " bytes\n" +
+                '}';
+        }
+    }
+};

dev/env/node_modules/adm-zip/headers/index.js

@@ -0,0 +1,2 @@
+exports.EntryHeader = require("./entryHeader");
+exports.MainHeader = require("./mainHeader");

dev/env/node_modules/adm-zip/headers/mainHeader.js

@@ -0,0 +1,98 @@
+var Utils = require("../util"),
+    Constants = Utils.Constants;
+
+/* The entries in the end of central directory */
+module.exports = function () {
+    var _volumeEntries = 0,
+        _totalEntries = 0,
+        _size = 0,
+        _offset = 0,
+        _commentLength = 0;
+
+    return {
+        get diskEntries () { return _volumeEntries },
+        set diskEntries (/*Number*/val) { _volumeEntries = _totalEntries = val; },
+
+        get totalEntries () { return _totalEntries },
+        set totalEntries (/*Number*/val) { _totalEntries = _volumeEntries = val; },
+
+        get size () { return _size },
+        set size (/*Number*/val) { _size = val; },
+
+        get offset () { return _offset },
+        set offset (/*Number*/val) { _offset = val; },
+
+        get commentLength () { return _commentLength },
+        set commentLength (/*Number*/val) { _commentLength = val; },
+
+        get mainHeaderSize () {
+            return Constants.ENDHDR + _commentLength;
+        },
+
+        loadFromBinary : function(/*Buffer*/data) {
+            // data should be 22 bytes and start with "PK 05 06"
+            // or be 56+ bytes and start with "PK 06 06" for Zip64
+            if ((data.length !== Constants.ENDHDR || data.readUInt32LE(0) !== Constants.ENDSIG) &&
+                (data.length < Constants.ZIP64HDR || data.readUInt32LE(0) !== Constants.ZIP64SIG)) {
+
+                throw new Error(Utils.Errors.INVALID_END);
+            }
+
+            if (data.readUInt32LE(0) === Constants.ENDSIG) {
+                // number of entries on this volume
+                _volumeEntries = data.readUInt16LE(Constants.ENDSUB);
+                // total number of entries
+                _totalEntries = data.readUInt16LE(Constants.ENDTOT);
+                // central directory size in bytes
+                _size = data.readUInt32LE(Constants.ENDSIZ);
+                // offset of first CEN header
+                _offset = data.readUInt32LE(Constants.ENDOFF);
+                // zip file comment length
+                _commentLength = data.readUInt16LE(Constants.ENDCOM);
+            } else {
+                // number of entries on this volume
+                _volumeEntries = Utils.readBigUInt64LE(data, Constants.ZIP64SUB);
+                // total number of entries
+                _totalEntries = Utils.readBigUInt64LE(data, Constants.ZIP64TOT);
+                // central directory size in bytes
+                _size = Utils.readBigUInt64LE(data, Constants.ZIP64SIZ);
+                // offset of first CEN header
+                _offset = Utils.readBigUInt64LE(data, Constants.ZIP64OFF);
+
+                _commentLength = 0;
+            }
+
+        },
+
+        toBinary : function() {
+           var b = Buffer.alloc(Constants.ENDHDR + _commentLength);
+            // "PK 05 06" signature
+            b.writeUInt32LE(Constants.ENDSIG, 0);
+            b.writeUInt32LE(0, 4);
+            // number of entries on this volume
+            b.writeUInt16LE(_volumeEntries, Constants.ENDSUB);
+            // total number of entries
+            b.writeUInt16LE(_totalEntries, Constants.ENDTOT);
+            // central directory size in bytes
+            b.writeUInt32LE(_size, Constants.ENDSIZ);
+            // offset of first CEN header
+            b.writeUInt32LE(_offset, Constants.ENDOFF);
+            // zip file comment length
+            b.writeUInt16LE(_commentLength, Constants.ENDCOM);
+            // fill comment memory with spaces so no garbage is left there
+            b.fill(" ", Constants.ENDHDR);
+
+            return b;
+        },
+
+        toString : function() {
+            return '{\n' +
+                '\t"diskEntries" : ' + _volumeEntries + ",\n" +
+                '\t"totalEntries" : ' + _totalEntries + ",\n" +
+                '\t"size" : ' + _size + " bytes,\n" +
+                '\t"offset" : 0x' + _offset.toString(16).toUpperCase() + ",\n" +
+                '\t"commentLength" : 0x' + _commentLength + "\n" +
+            '}';
+        }
+    }
+};

dev/env/node_modules/adm-zip/methods/deflater.js

@@ -0,0 +1,31 @@
+module.exports = function (/*Buffer*/inbuf) {
+
+  var zlib = require("zlib");
+  
+  var opts = {chunkSize: (parseInt(inbuf.length / 1024) + 1) * 1024};
+  
+  return {
+    deflate: function () {
+      return zlib.deflateRawSync(inbuf, opts);
+    },
+
+    deflateAsync: function (/*Function*/callback) {
+      var tmp = zlib.createDeflateRaw(opts), parts = [], total = 0;
+      tmp.on('data', function (data) {
+        parts.push(data);
+        total += data.length;
+      });
+      tmp.on('end', function () {
+        var buf = Buffer.alloc(total), written = 0;
+        buf.fill(0);
+        for (var i = 0; i < parts.length; i++) {
+          var part = parts[i];
+          part.copy(buf, written);
+          written += part.length;
+        }
+        callback && callback(buf);
+      });
+      tmp.end(inbuf);
+    }
+  }
+};

dev/env/node_modules/adm-zip/methods/index.js

@@ -0,0 +1,2 @@
+exports.Deflater = require("./deflater");
+exports.Inflater = require("./inflater");

dev/env/node_modules/adm-zip/methods/inflater.js

@@ -0,0 +1,29 @@
+module.exports = function (/*Buffer*/inbuf) {
+
+  var zlib = require("zlib");
+
+  return {
+    inflate: function () {
+      return zlib.inflateRawSync(inbuf);
+    },
+
+    inflateAsync: function (/*Function*/callback) {
+      var tmp = zlib.createInflateRaw(), parts = [], total = 0;
+      tmp.on('data', function (data) {
+        parts.push(data);
+        total += data.length;
+      });
+      tmp.on('end', function () {
+        var buf = Buffer.alloc(total), written = 0;
+        buf.fill(0);
+        for (var i = 0; i < parts.length; i++) {
+          var part = parts[i];
+          part.copy(buf, written);
+          written += part.length;
+        }
+        callback && callback(buf);
+      });
+      tmp.end(inbuf);
+    }
+  }
+};

dev/env/node_modules/adm-zip/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "adm-zip",
+  "version": "0.4.16",
+  "description": "Javascript implementation of zip for nodejs with support for electron original-fs. Allows user to create or extract zip files both in memory or to/from disk",
+  "scripts": {
+    "test": "mocha test/mocha.js test/crc/index.js"
+  },
+  "keywords": [
+    "zip",
+    "methods",
+    "archive",
+    "unzip"
+  ],
+  "homepage": "https://github.com/cthackers/adm-zip",
+  "author": "Nasca Iacob <sy@another-d-mention.ro> (https://github.com/cthackers)",
+  "bugs": {
+    "email": "sy@another-d-mention.ro",
+    "url": "https://github.com/cthackers/adm-zip/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "adm-zip.js",
+    "headers",
+    "methods",
+    "util",
+    "zipEntry.js",
+    "zipFile.js",
+    "MIT-LICENSE.txt"
+  ],
+  "main": "adm-zip.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cthackers/adm-zip.git"
+  },
+  "engines": {
+    "node": ">=0.3.0"
+  },
+  "devDependencies": {
+    "chai": "^4.1.2",
+    "mocha": "^8.0.1",
+    "rimraf": "^2.6.2"
+  }
+}

dev/env/node_modules/adm-zip/util/constants.js

@@ -0,0 +1,135 @@
+module.exports = {
+    /* The local file header */
+    LOCHDR           : 30, // LOC header size
+    LOCSIG           : 0x04034b50, // "PK\003\004"
+    LOCVER           : 4,	// version needed to extract
+    LOCFLG           : 6, // general purpose bit flag
+    LOCHOW           : 8, // compression method
+    LOCTIM           : 10, // modification time (2 bytes time, 2 bytes date)
+    LOCCRC           : 14, // uncompressed file crc-32 value
+    LOCSIZ           : 18, // compressed size
+    LOCLEN           : 22, // uncompressed size
+    LOCNAM           : 26, // filename length
+    LOCEXT           : 28, // extra field length
+
+    /* The Data descriptor */
+    EXTSIG           : 0x08074b50, // "PK\007\008"
+    EXTHDR           : 16, // EXT header size
+    EXTCRC           : 4, // uncompressed file crc-32 value
+    EXTSIZ           : 8, // compressed size
+    EXTLEN           : 12, // uncompressed size
+
+    /* The central directory file header */
+    CENHDR           : 46, // CEN header size
+    CENSIG           : 0x02014b50, // "PK\001\002"
+    CENVEM           : 4, // version made by
+    CENVER           : 6, // version needed to extract
+    CENFLG           : 8, // encrypt, decrypt flags
+    CENHOW           : 10, // compression method
+    CENTIM           : 12, // modification time (2 bytes time, 2 bytes date)
+    CENCRC           : 16, // uncompressed file crc-32 value
+    CENSIZ           : 20, // compressed size
+    CENLEN           : 24, // uncompressed size
+    CENNAM           : 28, // filename length
+    CENEXT           : 30, // extra field length
+    CENCOM           : 32, // file comment length
+    CENDSK           : 34, // volume number start
+    CENATT           : 36, // internal file attributes
+    CENATX           : 38, // external file attributes (host system dependent)
+    CENOFF           : 42, // LOC header offset
+
+    /* The entries in the end of central directory */
+    ENDHDR           : 22, // END header size
+    ENDSIG           : 0x06054b50, // "PK\005\006"
+    ENDSUB           : 8, // number of entries on this disk
+    ENDTOT           : 10, // total number of entries
+    ENDSIZ           : 12, // central directory size in bytes
+    ENDOFF           : 16, // offset of first CEN header
+    ENDCOM           : 20, // zip file comment length
+
+    END64HDR         : 20, // zip64 END header size
+    END64SIG         : 0x07064b50, // zip64 Locator signature, "PK\006\007"
+    END64START       : 4, // number of the disk with the start of the zip64
+    END64OFF         : 8, // relative offset of the zip64 end of central directory
+    END64NUMDISKS    : 16, // total number of disks
+
+    ZIP64SIG         : 0x06064b50, // zip64 signature, "PK\006\006"
+    ZIP64HDR         : 56, // zip64 record minimum size
+    ZIP64LEAD        : 12, // leading bytes at the start of the record, not counted by the value stored in ZIP64SIZE
+    ZIP64SIZE        : 4, // zip64 size of the central directory record
+    ZIP64VEM         : 12, // zip64 version made by
+    ZIP64VER         : 14, // zip64 version needed to extract
+    ZIP64DSK         : 16, // zip64 number of this disk
+    ZIP64DSKDIR      : 20, // number of the disk with the start of the record directory
+    ZIP64SUB         : 24, // number of entries on this disk
+    ZIP64TOT         : 32, // total number of entries
+    ZIP64SIZB        : 40, // zip64 central directory size in bytes
+    ZIP64OFF         : 48, // offset of start of central directory with respect to the starting disk number
+    ZIP64EXTRA       : 56, // extensible data sector
+
+    /* Compression methods */
+    STORED           : 0, // no compression
+    SHRUNK           : 1, // shrunk
+    REDUCED1         : 2, // reduced with compression factor 1
+    REDUCED2         : 3, // reduced with compression factor 2
+    REDUCED3         : 4, // reduced with compression factor 3
+    REDUCED4         : 5, // reduced with compression factor 4
+    IMPLODED         : 6, // imploded
+    // 7 reserved
+    DEFLATED         : 8, // deflated
+    ENHANCED_DEFLATED: 9, // enhanced deflated
+    PKWARE           : 10,// PKWare DCL imploded
+    // 11 reserved
+    BZIP2            : 12, //  compressed using BZIP2
+    // 13 reserved
+    LZMA             : 14, // LZMA
+    // 15-17 reserved
+    IBM_TERSE        : 18, // compressed using IBM TERSE
+    IBM_LZ77         : 19, //IBM LZ77 z
+
+    /* General purpose bit flag */
+    FLG_ENC          : 0,  // encripted file
+    FLG_COMP1        : 1,  // compression option
+    FLG_COMP2        : 2,  // compression option
+    FLG_DESC         : 4,  // data descriptor
+    FLG_ENH          : 8,  // enhanced deflation
+    FLG_STR          : 16, // strong encryption
+    FLG_LNG          : 1024, // language encoding
+    FLG_MSK          : 4096, // mask header values
+
+    /* Load type */
+    FILE             : 0,
+    BUFFER           : 1,
+    NONE             : 2,
+
+    /* 4.5 Extensible data fields */
+    EF_ID            : 0,
+    EF_SIZE          : 2,
+
+    /* Header IDs */
+    ID_ZIP64         : 0x0001,
+    ID_AVINFO        : 0x0007,
+    ID_PFS           : 0x0008,
+    ID_OS2           : 0x0009,
+    ID_NTFS          : 0x000a,
+    ID_OPENVMS       : 0x000c,
+    ID_UNIX          : 0x000d,
+    ID_FORK          : 0x000e,
+    ID_PATCH         : 0x000f,
+    ID_X509_PKCS7    : 0x0014,
+    ID_X509_CERTID_F : 0x0015,
+    ID_X509_CERTID_C : 0x0016,
+    ID_STRONGENC     : 0x0017,
+    ID_RECORD_MGT    : 0x0018,
+    ID_X509_PKCS7_RL : 0x0019,
+    ID_IBM1          : 0x0065,
+    ID_IBM2          : 0x0066,
+    ID_POSZIP        : 0x4690,
+
+    EF_ZIP64_OR_32   : 0xffffffff,
+    EF_ZIP64_OR_16   : 0xffff,
+    EF_ZIP64_SUNCOMP : 0,
+    EF_ZIP64_SCOMP   : 8,
+    EF_ZIP64_RHO     : 16,
+    EF_ZIP64_DSN     : 24
+};

dev/env/node_modules/adm-zip/util/errors.js

@@ -0,0 +1,35 @@
+module.exports = {
+    /* Header error messages */
+    "INVALID_LOC" : "Invalid LOC header (bad signature)",
+    "INVALID_CEN" : "Invalid CEN header (bad signature)",
+    "INVALID_END" : "Invalid END header (bad signature)",
+
+    /* ZipEntry error messages*/
+    "NO_DATA" : "Nothing to decompress",
+    "BAD_CRC" : "CRC32 checksum failed",
+    "FILE_IN_THE_WAY" : "There is a file in the way: %s",
+    "UNKNOWN_METHOD" : "Invalid/unsupported compression method",
+
+    /* Inflater error messages */
+    "AVAIL_DATA" : "inflate::Available inflate data did not terminate",
+    "INVALID_DISTANCE" : "inflate::Invalid literal/length or distance code in fixed or dynamic block",
+    "TO_MANY_CODES" : "inflate::Dynamic block code description: too many length or distance codes",
+    "INVALID_REPEAT_LEN" : "inflate::Dynamic block code description: repeat more than specified lengths",
+    "INVALID_REPEAT_FIRST" : "inflate::Dynamic block code description: repeat lengths with no first length",
+    "INCOMPLETE_CODES" : "inflate::Dynamic block code description: code lengths codes incomplete",
+    "INVALID_DYN_DISTANCE": "inflate::Dynamic block code description: invalid distance code lengths",
+    "INVALID_CODES_LEN": "inflate::Dynamic block code description: invalid literal/length code lengths",
+    "INVALID_STORE_BLOCK" : "inflate::Stored block length did not match one's complement",
+    "INVALID_BLOCK_TYPE" : "inflate::Invalid block type (type == 3)",
+
+    /* ADM-ZIP error messages */
+    "CANT_EXTRACT_FILE" : "Could not extract the file",
+    "CANT_OVERRIDE" : "Target file already exists",
+    "NO_ZIP" : "No zip file was loaded",
+    "NO_ENTRY" : "Entry doesn't exist",
+    "DIRECTORY_CONTENT_ERROR" : "A directory cannot have content",
+    "FILE_NOT_FOUND" : "File not found: %s",
+    "NOT_IMPLEMENTED" : "Not implemented",
+    "INVALID_FILENAME" : "Invalid filename",
+    "INVALID_FORMAT" : "Invalid or unsupported zip format. No END header found"
+};

dev/env/node_modules/adm-zip/util/fattr.js

@@ -0,0 +1,84 @@
+var fs = require("./fileSystem").require(),
+    pth = require("path");
+	
+fs.existsSync = fs.existsSync || pth.existsSync;
+
+module.exports = function(/*String*/path) {
+
+    var _path = path || "",
+        _permissions = 0,
+        _obj = newAttr(),
+        _stat = null;
+
+    function newAttr() {
+        return {
+            directory : false,
+            readonly : false,
+            hidden : false,
+            executable : false,
+            mtime : 0,
+            atime : 0
+        }
+    }
+
+    if (_path && fs.existsSync(_path)) {
+        _stat = fs.statSync(_path);
+        _obj.directory = _stat.isDirectory();
+        _obj.mtime = _stat.mtime;
+        _obj.atime = _stat.atime;
+        _obj.executable = !!(1 & parseInt ((_stat.mode & parseInt ("777", 8)).toString (8)[0]));
+        _obj.readonly = !!(2 & parseInt ((_stat.mode & parseInt ("777", 8)).toString (8)[0]));
+        _obj.hidden = pth.basename(_path)[0] === ".";
+    } else {
+        console.warn("Invalid path: " + _path)
+    }
+
+    return {
+
+        get directory () {
+            return _obj.directory;
+        },
+
+        get readOnly () {
+            return _obj.readonly;
+        },
+
+        get hidden () {
+            return _obj.hidden;
+        },
+
+        get mtime () {
+            return _obj.mtime;
+        },
+
+        get atime () {
+           return _obj.atime;
+        },
+
+
+        get executable () {
+            return _obj.executable;
+        },
+
+        decodeAttributes : function(val) {
+
+        },
+
+        encodeAttributes : function (val) {
+
+        },
+
+        toString : function() {
+           return '{\n' +
+               '\t"path" : "' + _path + ",\n" +
+               '\t"isDirectory" : ' + _obj.directory + ",\n" +
+               '\t"isReadOnly" : ' + _obj.readonly + ",\n" +
+               '\t"isHidden" : ' + _obj.hidden + ",\n" +
+               '\t"isExecutable" : ' + _obj.executable + ",\n" +
+               '\t"mTime" : ' + _obj.mtime + "\n" +
+               '\t"aTime" : ' + _obj.atime + "\n" +
+           '}';
+        }
+    }
+
+};

dev/env/node_modules/adm-zip/util/fileSystem.js

@@ -0,0 +1,12 @@
+exports.require = function() {
+  var fs = require("fs");
+  if (process.versions['electron']) {
+	  try {
+	    originalFs = require("original-fs");
+	    if (Object.keys(originalFs).length > 0) {
+	      fs = originalFs;
+      }
+	  } catch (e) {}
+  }
+  return fs
+};

dev/env/node_modules/adm-zip/util/index.js

@@ -0,0 +1,5 @@
+module.exports = require("./utils");
+module.exports.FileSystem = require("./fileSystem");
+module.exports.Constants = require("./constants");
+module.exports.Errors = require("./errors");
+module.exports.FileAttr = require("./fattr");

dev/env/node_modules/adm-zip/util/utils.js

@@ -0,0 +1,218 @@
+var fs = require("./fileSystem").require(),
+    pth = require('path');
+
+fs.existsSync = fs.existsSync || pth.existsSync;
+
+module.exports = (function() {
+
+    var crcTable = [],
+        Constants = require('./constants'),
+        Errors = require('./errors'),
+
+        PATH_SEPARATOR = pth.sep;
+
+
+    function mkdirSync(/*String*/path) {
+        var resolvedPath = path.split(PATH_SEPARATOR)[0];
+        path.split(PATH_SEPARATOR).forEach(function(name) {
+            if (!name || name.substr(-1,1) === ":") return;
+            resolvedPath += PATH_SEPARATOR + name;
+            var stat;
+            try {
+                stat = fs.statSync(resolvedPath);
+            } catch (e) {
+                fs.mkdirSync(resolvedPath);
+            }
+            if (stat && stat.isFile())
+                throw Errors.FILE_IN_THE_WAY.replace("%s", resolvedPath);
+        });
+    }
+
+    function findSync(/*String*/dir, /*RegExp*/pattern, /*Boolean*/recoursive) {
+        if (typeof pattern === 'boolean') {
+            recoursive = pattern;
+            pattern = undefined;
+        }
+        var files = [];
+        fs.readdirSync(dir).forEach(function(file) {
+            var path = pth.join(dir, file);
+
+            if (fs.statSync(path).isDirectory() && recoursive)
+                files = files.concat(findSync(path, pattern, recoursive));
+
+            if (!pattern || pattern.test(path)) {
+                files.push(pth.normalize(path) + (fs.statSync(path).isDirectory() ? PATH_SEPARATOR : ""));
+            }
+
+        });
+        return files;
+    }
+
+    function readBigUInt64LE(/*Buffer*/buffer, /*int*/index) {
+        var slice = Buffer.from(buffer.slice(index, index + 8));
+        slice.swap64();
+
+        return parseInt(`0x${ slice.toString('hex') }`);
+    }
+
+    return {
+        makeDir : function(/*String*/path) {
+            mkdirSync(path);
+        },
+
+        crc32 : function(buf) {
+            if (typeof buf === 'string') {
+                buf = Buffer.alloc(buf.length, buf);
+            }
+            var b = Buffer.alloc(4);
+            if (!crcTable.length) {
+                for (var n = 0; n < 256; n++) {
+                    var c = n;
+                    for (var k = 8; --k >= 0;)  //
+                        if ((c & 1) !== 0)  { c = 0xedb88320 ^ (c >>> 1); } else { c = c >>> 1; }
+                    if (c < 0) {
+                        b.writeInt32LE(c, 0);
+                        c = b.readUInt32LE(0);
+                    }
+                    crcTable[n] = c;
+                }
+            }
+            var crc = 0, off = 0, len = buf.length, c1 = ~crc;
+            while(--len >= 0) c1 = crcTable[(c1 ^ buf[off++]) & 0xff] ^ (c1 >>> 8);
+            crc = ~c1;
+            b.writeInt32LE(crc & 0xffffffff, 0);
+            return b.readUInt32LE(0);
+        },
+
+        methodToString : function(/*Number*/method) {
+            switch (method) {
+                case Constants.STORED:
+                    return 'STORED (' + method + ')';
+                case Constants.DEFLATED:
+                    return 'DEFLATED (' + method + ')';
+                default:
+                    return 'UNSUPPORTED (' + method + ')';
+            }
+
+        },
+
+        writeFileTo : function(/*String*/path, /*Buffer*/content, /*Boolean*/overwrite, /*Number*/attr) {
+            if (fs.existsSync(path)) {
+                if (!overwrite)
+                    return false; // cannot overwrite
+
+                var stat = fs.statSync(path);
+                if (stat.isDirectory()) {
+                    return false;
+                }
+            }
+            var folder = pth.dirname(path);
+            if (!fs.existsSync(folder)) {
+                mkdirSync(folder);
+            }
+
+            var fd;
+            try {
+                fd = fs.openSync(path, 'w', 438); // 0666
+            } catch(e) {
+                fs.chmodSync(path, 438);
+                fd = fs.openSync(path, 'w', 438);
+            }
+            if (fd) {
+                try {
+                    fs.writeSync(fd, content, 0, content.length, 0);
+                }
+                catch (e){
+                    throw e;
+                }
+                finally {
+                    fs.closeSync(fd);
+                }
+            }
+            fs.chmodSync(path, attr || 438);
+            return true;
+        },
+
+        writeFileToAsync : function(/*String*/path, /*Buffer*/content, /*Boolean*/overwrite, /*Number*/attr, /*Function*/callback) {
+            if(typeof attr === 'function') {
+                callback = attr;
+                attr = undefined;
+            }
+
+            fs.exists(path, function(exists) {
+                if(exists && !overwrite)
+                    return callback(false);
+
+                fs.stat(path, function(err, stat) {
+                    if(exists &&stat.isDirectory()) {
+                        return callback(false);
+                    }
+
+                    var folder = pth.dirname(path);
+                    fs.exists(folder, function(exists) {
+                        if(!exists)
+                            mkdirSync(folder);
+
+                        fs.open(path, 'w', 438, function(err, fd) {
+                            if(err) {
+                                fs.chmod(path, 438, function() {
+                                    fs.open(path, 'w', 438, function(err, fd) {
+                                        fs.write(fd, content, 0, content.length, 0, function() {
+                                            fs.close(fd, function() {
+                                                fs.chmod(path, attr || 438, function() {
+                                                    callback(true);
+                                                })
+                                            });
+                                        });
+                                    });
+                                })
+                            } else {
+                                if(fd) {
+                                    fs.write(fd, content, 0, content.length, 0, function() {
+                                        fs.close(fd, function() {
+                                            fs.chmod(path, attr || 438, function() {
+                                                callback(true);
+                                            })
+                                        });
+                                    });
+                                } else {
+                                    fs.chmod(path, attr || 438, function() {
+                                        callback(true);
+                                    })
+                                }
+                            }
+                        });
+                    })
+                })
+            })
+        },
+
+        findFiles : function(/*String*/path) {
+            return findSync(path, true);
+        },
+
+        getAttributes : function(/*String*/path) {
+
+        },
+
+        setAttributes : function(/*String*/path) {
+
+        },
+
+        toBuffer : function(input) {
+            if (Buffer.isBuffer(input)) {
+                return input;
+            } else {
+                if (input.length === 0) {
+                    return Buffer.alloc(0)
+                }
+                return Buffer.from(input, 'utf8');
+            }
+        },
+
+        readBigUInt64LE,
+
+        Constants : Constants,
+        Errors : Errors
+    }
+})();

dev/env/node_modules/adm-zip/zipEntry.js

@@ -0,0 +1,291 @@
+var Utils = require("./util"),
+    Headers = require("./headers"),
+    Constants = Utils.Constants,
+    Methods = require("./methods");
+
+module.exports = function (/*Buffer*/input) {
+
+    var _entryHeader = new Headers.EntryHeader(),
+        _entryName = Buffer.alloc(0),
+        _comment = Buffer.alloc(0),
+        _isDirectory = false,
+        uncompressedData = null,
+        _extra = Buffer.alloc(0);
+
+    function getCompressedDataFromZip() {
+        if (!input || !Buffer.isBuffer(input)) {
+            return Buffer.alloc(0);
+        }
+        _entryHeader.loadDataHeaderFromBinary(input);
+        return input.slice(_entryHeader.realDataOffset, _entryHeader.realDataOffset + _entryHeader.compressedSize)
+    }
+
+    function crc32OK(data) {
+        // if bit 3 (0x08) of the general-purpose flags field is set, then the CRC-32 and file sizes are not known when the header is written
+        if ((_entryHeader.flags & 0x8) !== 0x8) {
+           if (Utils.crc32(data) !== _entryHeader.dataHeader.crc) {
+               return false;
+           }
+        } else {
+            // @TODO: load and check data descriptor header
+            // The fields in the local header are filled with zero, and the CRC-32 and size are appended in a 12-byte structure
+            // (optionally preceded by a 4-byte signature) immediately after the compressed data:
+        }
+        return true;
+    }
+
+    function decompress(/*Boolean*/async, /*Function*/callback, /*String*/pass) {
+        if(typeof callback === 'undefined' && typeof async === 'string') {
+            pass=async;
+            async=void 0;
+        }
+        if (_isDirectory) {
+            if (async && callback) {
+                callback(Buffer.alloc(0), Utils.Errors.DIRECTORY_CONTENT_ERROR); //si added error.
+            }
+            return Buffer.alloc(0);
+        }
+
+        var compressedData = getCompressedDataFromZip();
+
+        if (compressedData.length === 0) {
+            // File is empty, nothing to decompress.
+            if (async && callback) callback(compressedData);
+            return compressedData;
+        }
+
+        var data = Buffer.alloc(_entryHeader.size);
+
+        switch (_entryHeader.method) {
+            case Utils.Constants.STORED:
+                compressedData.copy(data);
+                if (!crc32OK(data)) {
+                    if (async && callback) callback(data, Utils.Errors.BAD_CRC);//si added error
+                    throw new Error(Utils.Errors.BAD_CRC);
+                } else {//si added otherwise did not seem to return data.
+                    if (async && callback) callback(data);
+                    return data;
+                }
+            case Utils.Constants.DEFLATED:
+                var inflater = new Methods.Inflater(compressedData);
+                if (!async) {
+                    var result = inflater.inflate(data);
+                    result.copy(data, 0);
+                    if (!crc32OK(data)) {
+                        throw new Error(Utils.Errors.BAD_CRC + " " + _entryName.toString());
+                    }
+                    return data;
+                } else {
+                    inflater.inflateAsync(function(result) {
+                        result.copy(data, 0);
+                        if (!crc32OK(data)) {
+                            if (callback) callback(data, Utils.Errors.BAD_CRC); //si added error
+                        } else { //si added otherwise did not seem to return data.
+                            if (callback) callback(data);
+                        }
+                    })
+                }
+                break;
+            default:
+                if (async && callback) callback(Buffer.alloc(0), Utils.Errors.UNKNOWN_METHOD);
+                throw new Error(Utils.Errors.UNKNOWN_METHOD);
+        }
+    }
+
+    function compress(/*Boolean*/async, /*Function*/callback) {
+        if ((!uncompressedData || !uncompressedData.length) && Buffer.isBuffer(input)) {
+            // no data set or the data wasn't changed to require recompression
+            if (async && callback) callback(getCompressedDataFromZip());
+            return getCompressedDataFromZip();
+        }
+
+        if (uncompressedData.length && !_isDirectory) {
+            var compressedData;
+            // Local file header
+            switch (_entryHeader.method) {
+                case Utils.Constants.STORED:
+                    _entryHeader.compressedSize = _entryHeader.size;
+
+                    compressedData = Buffer.alloc(uncompressedData.length);
+                    uncompressedData.copy(compressedData);
+
+                    if (async && callback) callback(compressedData);
+                    return compressedData;
+                default:
+                case Utils.Constants.DEFLATED:
+
+                    var deflater = new Methods.Deflater(uncompressedData);
+                    if (!async) {
+                        var deflated = deflater.deflate();
+                        _entryHeader.compressedSize = deflated.length;
+                        return deflated;
+                    } else {
+                        deflater.deflateAsync(function(data) {
+                            compressedData = Buffer.alloc(data.length);
+                            _entryHeader.compressedSize = data.length;
+                            data.copy(compressedData);
+                            callback && callback(compressedData);
+                        })
+                    }
+                    deflater = null;
+                    break;
+            }
+        } else {
+            if (async && callback) {
+                callback(Buffer.alloc(0));
+            } else {
+                return Buffer.alloc(0);
+            }
+        }
+    }
+
+    function readUInt64LE(buffer, offset) {
+        return (buffer.readUInt32LE(offset + 4) << 4) + buffer.readUInt32LE(offset);
+    }
+
+    function parseExtra(data) {
+        var offset = 0;
+        var signature, size, part;
+        while(offset<data.length) {
+            signature = data.readUInt16LE(offset);
+            offset += 2;
+            size = data.readUInt16LE(offset);
+            offset += 2;
+            part = data.slice(offset, offset+size);
+            offset += size;
+            if(Constants.ID_ZIP64 === signature) {
+                parseZip64ExtendedInformation(part);
+            }
+        }
+    }
+
+    //Override header field values with values from the ZIP64 extra field
+    function parseZip64ExtendedInformation(data) {
+        var size, compressedSize, offset, diskNumStart;
+
+        if(data.length >= Constants.EF_ZIP64_SCOMP) {
+            size = readUInt64LE(data, Constants.EF_ZIP64_SUNCOMP);
+            if(_entryHeader.size === Constants.EF_ZIP64_OR_32) {
+                _entryHeader.size = size;
+            }
+        }
+        if(data.length >= Constants.EF_ZIP64_RHO) {
+            compressedSize = readUInt64LE(data, Constants.EF_ZIP64_SCOMP);
+            if(_entryHeader.compressedSize === Constants.EF_ZIP64_OR_32) {
+                _entryHeader.compressedSize = compressedSize;
+            }
+        }
+        if(data.length >= Constants.EF_ZIP64_DSN) {
+            offset = readUInt64LE(data, Constants.EF_ZIP64_RHO);
+            if(_entryHeader.offset === Constants.EF_ZIP64_OR_32) {
+                _entryHeader.offset = offset;
+            }
+        }
+        if(data.length >= Constants.EF_ZIP64_DSN+4) {
+            diskNumStart = data.readUInt32LE(Constants.EF_ZIP64_DSN);
+            if(_entryHeader.diskNumStart === Constants.EF_ZIP64_OR_16) {
+                _entryHeader.diskNumStart = diskNumStart;
+            }
+        }
+    }
+
+
+    return {
+        get entryName () { return _entryName.toString(); },
+        get rawEntryName() { return _entryName; },
+        set entryName (val) {
+            _entryName = Utils.toBuffer(val);
+            var lastChar = _entryName[_entryName.length - 1];
+            _isDirectory = (lastChar === 47) || (lastChar === 92);
+            _entryHeader.fileNameLength = _entryName.length;
+        },
+
+        get extra () { return _extra; },
+        set extra (val) {
+            _extra = val;
+            _entryHeader.extraLength = val.length;
+            parseExtra(val);
+        },
+
+        get comment () { return _comment.toString(); },
+        set comment (val) {
+            _comment = Utils.toBuffer(val);
+            _entryHeader.commentLength = _comment.length;
+        },
+
+        get name () { var n = _entryName.toString(); return _isDirectory ? n.substr(n.length - 1).split("/").pop() : n.split("/").pop(); },
+        get isDirectory () { return _isDirectory },
+
+        getCompressedData : function() {
+            return compress(false, null)
+        },
+
+        getCompressedDataAsync : function(/*Function*/callback) {
+            compress(true, callback)
+        },
+
+        setData : function(value) {
+            uncompressedData = Utils.toBuffer(value);
+            if (!_isDirectory && uncompressedData.length) {
+                _entryHeader.size = uncompressedData.length;
+                _entryHeader.method = Utils.Constants.DEFLATED;
+                _entryHeader.crc = Utils.crc32(value);
+                _entryHeader.changed = true;
+            } else { // folders and blank files should be stored
+                _entryHeader.method = Utils.Constants.STORED;
+            }
+        },
+
+        getData : function(pass) {
+            if (_entryHeader.changed) {
+				return uncompressedData;
+			} else {
+				return decompress(false, null, pass);
+            }
+        },
+
+        getDataAsync : function(/*Function*/callback, pass) {
+			if (_entryHeader.changed) {
+				callback(uncompressedData)
+			} else {
+				decompress(true, callback, pass)
+            }
+        },
+
+        set attr(attr) { _entryHeader.attr = attr; },
+        get attr() { return _entryHeader.attr; },
+
+        set header(/*Buffer*/data) {
+            _entryHeader.loadFromBinary(data);
+        },
+
+        get header() {
+            return _entryHeader;
+        },
+
+        packHeader : function() {
+            var header = _entryHeader.entryHeaderToBinary();
+            // add
+            _entryName.copy(header, Utils.Constants.CENHDR);
+            if (_entryHeader.extraLength) {
+                _extra.copy(header, Utils.Constants.CENHDR + _entryName.length)
+            }
+            if (_entryHeader.commentLength) {
+                _comment.copy(header, Utils.Constants.CENHDR + _entryName.length + _entryHeader.extraLength, _comment.length);
+            }
+            return header;
+        },
+
+        toString : function() {
+            return '{\n' +
+                '\t"entryName" : "' + _entryName.toString() + "\",\n" +
+                '\t"name" : "' + (_isDirectory ? _entryName.toString().replace(/\/$/, '').split("/").pop() : _entryName.toString().split("/").pop()) + "\",\n" +
+                '\t"comment" : "' + _comment.toString() + "\",\n" +
+                '\t"isDirectory" : ' + _isDirectory + ",\n" +
+                '\t"header" : ' + _entryHeader.toString().replace(/\t/mg, "\t\t").replace(/}/mg, "\t}")  + ",\n" +
+                '\t"compressedData" : <' + (input && input.length  + " bytes buffer" || "null") + ">\n" +
+                '\t"data" : <' + (uncompressedData && uncompressedData.length  + " bytes buffer" || "null") + ">\n" +
+                '}';
+        }
+    }
+};

dev/env/node_modules/adm-zip/zipFile.js

@@ -0,0 +1,408 @@
+var ZipEntry = require("./zipEntry"),
+	Headers = require("./headers"),
+	Utils = require("./util");
+
+module.exports = function (/*String|Buffer*/input, /*Number*/inputType) {
+	var entryList = [],
+		entryTable = {},
+		_comment = Buffer.alloc(0),
+		filename = "",
+		fs = Utils.FileSystem.require(),
+		inBuffer = null,
+		mainHeader = new Headers.MainHeader(),
+		loadedEntries = false;
+
+	if (inputType === Utils.Constants.FILE) {
+		// is a filename
+		filename = input;
+		inBuffer = fs.readFileSync(filename);
+		readMainHeader();
+	} else if (inputType === Utils.Constants.BUFFER) {
+		// is a memory buffer
+		inBuffer = input;
+		readMainHeader();
+	} else {
+		// none. is a new file
+		loadedEntries = true;
+	}
+
+	function iterateEntries(callback) {
+		const totalEntries = mainHeader.diskEntries; // total number of entries
+		let index = mainHeader.offset; // offset of first CEN header
+
+		for (let i = 0; i < totalEntries; i++) {
+			let tmp = index;
+			const entry = new ZipEntry(inBuffer);
+
+			entry.header = inBuffer.slice(tmp, tmp += Utils.Constants.CENHDR);
+			entry.entryName = inBuffer.slice(tmp, tmp += entry.header.fileNameLength);
+
+			index += entry.header.entryHeaderSize;
+
+			callback(entry);
+		}
+	}
+
+	function readEntries() {
+		loadedEntries = true;
+		entryTable = {};
+		entryList = new Array(mainHeader.diskEntries);  // total number of entries
+		var index = mainHeader.offset;  // offset of first CEN header
+		for (var i = 0; i < entryList.length; i++) {
+
+			var tmp = index,
+				entry = new ZipEntry(inBuffer);
+			entry.header = inBuffer.slice(tmp, tmp += Utils.Constants.CENHDR);
+
+			entry.entryName = inBuffer.slice(tmp, tmp += entry.header.fileNameLength);
+
+			if (entry.header.extraLength) {
+				entry.extra = inBuffer.slice(tmp, tmp += entry.header.extraLength);
+			}
+
+			if (entry.header.commentLength)
+				entry.comment = inBuffer.slice(tmp, tmp + entry.header.commentLength);
+
+			index += entry.header.entryHeaderSize;
+
+			entryList[i] = entry;
+			entryTable[entry.entryName] = entry;
+		}
+	}
+
+	function readMainHeader() {
+		var i = inBuffer.length - Utils.Constants.ENDHDR, // END header size
+			max = Math.max(0, i - 0xFFFF), // 0xFFFF is the max zip file comment length
+			n = max,
+			endStart = inBuffer.length,
+			endOffset = -1, // Start offset of the END header
+			commentEnd = 0;
+
+		for (i; i >= n; i--) {
+			if (inBuffer[i] !== 0x50) continue; // quick check that the byte is 'P'
+			if (inBuffer.readUInt32LE(i) === Utils.Constants.ENDSIG) { // "PK\005\006"
+				endOffset = i;
+				commentEnd = i;
+				endStart = i + Utils.Constants.ENDHDR;
+				// We already found a regular signature, let's look just a bit further to check if there's any zip64 signature
+				n = i - Utils.Constants.END64HDR;
+				continue;
+			}
+
+			if (inBuffer.readUInt32LE(i) === Utils.Constants.END64SIG) {
+				// Found a zip64 signature, let's continue reading the whole zip64 record
+				n = max;
+				continue;
+			}
+
+			if (inBuffer.readUInt32LE(i) == Utils.Constants.ZIP64SIG) {
+				// Found the zip64 record, let's determine it's size
+				endOffset = i;
+				endStart = i + Utils.readBigUInt64LE(inBuffer, i + Utils.Constants.ZIP64SIZE) + Utils.Constants.ZIP64LEAD;
+				break;
+			}
+		}
+
+		if (!~endOffset)
+			throw new Error(Utils.Errors.INVALID_FORMAT);
+
+		mainHeader.loadFromBinary(inBuffer.slice(endOffset, endStart));
+		if (mainHeader.commentLength) {
+			_comment = inBuffer.slice(commentEnd + Utils.Constants.ENDHDR);
+		}
+		// readEntries();
+	}
+
+	return {
+		/**
+		 * Returns an array of ZipEntry objects existent in the current opened archive
+		 * @return Array
+		 */
+		get entries() {
+			if (!loadedEntries) {
+				readEntries();
+			}
+			return entryList;
+		},
+
+		/**
+		 * Archive comment
+		 * @return {String}
+		 */
+		get comment() {
+			return _comment.toString();
+		},
+		set comment(val) {
+			mainHeader.commentLength = val.length;
+			_comment = val;
+		},
+
+		getEntryCount: function() {
+			if (!loadedEntries) {
+				return mainHeader.diskEntries;
+			}
+
+			return entryList.length;
+		},
+
+		forEach: function(callback) {
+			if (!loadedEntries) {
+				iterateEntries(callback);
+				return;
+			}
+
+			entryList.forEach(callback);
+		},
+
+		/**
+		 * Returns a reference to the entry with the given name or null if entry is inexistent
+		 *
+		 * @param entryName
+		 * @return ZipEntry
+		 */
+		getEntry: function (/*String*/entryName) {
+			if (!loadedEntries) {
+				readEntries();
+			}
+			return entryTable[entryName] || null;
+		},
+
+		/**
+		 * Adds the given entry to the entry list
+		 *
+		 * @param entry
+		 */
+		setEntry: function (/*ZipEntry*/entry) {
+			if (!loadedEntries) {
+				readEntries();
+			}
+			entryList.push(entry);
+			entryTable[entry.entryName] = entry;
+			mainHeader.totalEntries = entryList.length;
+		},
+
+		/**
+		 * Removes the entry with the given name from the entry list.
+		 *
+		 * If the entry is a directory, then all nested files and directories will be removed
+		 * @param entryName
+		 */
+		deleteEntry: function (/*String*/entryName) {
+			if (!loadedEntries) {
+				readEntries();
+			}
+			var entry = entryTable[entryName];
+			if (entry && entry.isDirectory) {
+				var _self = this;
+				this.getEntryChildren(entry).forEach(function (child) {
+					if (child.entryName !== entryName) {
+						_self.deleteEntry(child.entryName)
+					}
+				})
+			}
+			entryList.splice(entryList.indexOf(entry), 1);
+			delete(entryTable[entryName]);
+			mainHeader.totalEntries = entryList.length;
+		},
+
+		/**
+		 *  Iterates and returns all nested files and directories of the given entry
+		 *
+		 * @param entry
+		 * @return Array
+		 */
+		getEntryChildren: function (/*ZipEntry*/entry) {
+			if (!loadedEntries) {
+				readEntries();
+			}
+			if (entry.isDirectory) {
+				var list = [],
+					name = entry.entryName,
+					len = name.length;
+
+				entryList.forEach(function (zipEntry) {
+					if (zipEntry.entryName.substr(0, len) === name) {
+						list.push(zipEntry);
+					}
+				});
+				return list;
+			}
+			return []
+		},
+
+		/**
+		 * Returns the zip file
+		 *
+		 * @return Buffer
+		 */
+		compressToBuffer: function () {
+			if (!loadedEntries) {
+				readEntries();
+			}
+			if (entryList.length > 1) {
+				entryList.sort(function (a, b) {
+					var nameA = a.entryName.toLowerCase();
+					var nameB = b.entryName.toLowerCase();
+					if (nameA < nameB) {
+						return -1
+					}
+					if (nameA > nameB) {
+						return 1
+					}
+					return 0;
+				});
+			}
+
+			var totalSize = 0,
+				dataBlock = [],
+				entryHeaders = [],
+				dindex = 0;
+
+			mainHeader.size = 0;
+			mainHeader.offset = 0;
+
+			entryList.forEach(function (entry) {
+				// compress data and set local and entry header accordingly. Reason why is called first
+				var compressedData = entry.getCompressedData();
+				// data header
+				entry.header.offset = dindex;
+				var dataHeader = entry.header.dataHeaderToBinary();
+				var entryNameLen = entry.rawEntryName.length;
+				var extra = entry.extra.toString();
+				var postHeader = Buffer.alloc(entryNameLen + extra.length);
+				entry.rawEntryName.copy(postHeader, 0);
+				postHeader.fill(extra, entryNameLen);
+
+				var dataLength = dataHeader.length + postHeader.length + compressedData.length;
+
+				dindex += dataLength;
+
+				dataBlock.push(dataHeader);
+				dataBlock.push(postHeader);
+				dataBlock.push(compressedData);
+
+				var entryHeader = entry.packHeader();
+				entryHeaders.push(entryHeader);
+				mainHeader.size += entryHeader.length;
+				totalSize += (dataLength + entryHeader.length);
+			});
+
+			totalSize += mainHeader.mainHeaderSize; // also includes zip file comment length
+			// point to end of data and beginning of central directory first record
+			mainHeader.offset = dindex;
+
+			dindex = 0;
+			var outBuffer = Buffer.alloc(totalSize);
+			dataBlock.forEach(function (content) {
+				content.copy(outBuffer, dindex); // write data blocks
+				dindex += content.length;
+			});
+			entryHeaders.forEach(function (content) {
+				content.copy(outBuffer, dindex); // write central directory entries
+				dindex += content.length;
+			});
+
+			var mh = mainHeader.toBinary();
+			if (_comment) {
+				Buffer.from(_comment).copy(mh, Utils.Constants.ENDHDR); // add zip file comment
+			}
+
+			mh.copy(outBuffer, dindex); // write main header
+
+			return outBuffer
+		},
+
+		toAsyncBuffer: function (/*Function*/onSuccess, /*Function*/onFail, /*Function*/onItemStart, /*Function*/onItemEnd) {
+			if (!loadedEntries) {
+				readEntries();
+			}
+			if (entryList.length > 1) {
+				entryList.sort(function (a, b) {
+					var nameA = a.entryName.toLowerCase();
+					var nameB = b.entryName.toLowerCase();
+					if (nameA > nameB) {
+						return -1
+					}
+					if (nameA < nameB) {
+						return 1
+					}
+					return 0;
+				});
+			}
+
+			var totalSize = 0,
+				dataBlock = [],
+				entryHeaders = [],
+				dindex = 0;
+
+			mainHeader.size = 0;
+			mainHeader.offset = 0;
+
+			var compress = function (entryList) {
+				var self = arguments.callee;
+				if (entryList.length) {
+					var entry = entryList.pop();
+					var name = entry.entryName + entry.extra.toString();
+					if (onItemStart) onItemStart(name);
+					entry.getCompressedDataAsync(function (compressedData) {
+						if (onItemEnd) onItemEnd(name);
+
+						entry.header.offset = dindex;
+						// data header
+						var dataHeader = entry.header.dataHeaderToBinary();
+						var postHeader;
+						try {
+							postHeader = Buffer.alloc(name.length, name);  // using alloc will work on node  5.x+
+						} catch(e){
+							postHeader = new Buffer(name); // use deprecated method if alloc fails...
+						}
+						var dataLength = dataHeader.length + postHeader.length + compressedData.length;
+
+						dindex += dataLength;
+
+						dataBlock.push(dataHeader);
+						dataBlock.push(postHeader);
+						dataBlock.push(compressedData);
+
+						var entryHeader = entry.packHeader();
+						entryHeaders.push(entryHeader);
+						mainHeader.size += entryHeader.length;
+						totalSize += (dataLength + entryHeader.length);
+
+						if (entryList.length) {
+							self(entryList);
+						} else {
+
+
+							totalSize += mainHeader.mainHeaderSize; // also includes zip file comment length
+							// point to end of data and beginning of central directory first record
+							mainHeader.offset = dindex;
+
+							dindex = 0;
+							var outBuffer = Buffer.alloc(totalSize);
+							dataBlock.forEach(function (content) {
+								content.copy(outBuffer, dindex); // write data blocks
+								dindex += content.length;
+							});
+							entryHeaders.forEach(function (content) {
+								content.copy(outBuffer, dindex); // write central directory entries
+								dindex += content.length;
+							});
+
+							var mh = mainHeader.toBinary();
+							if (_comment) {
+								_comment.copy(mh, Utils.Constants.ENDHDR); // add zip file comment
+							}
+
+							mh.copy(outBuffer, dindex); // write main header
+
+							onSuccess(outBuffer);
+						}
+					});
+				}
+			};
+
+			compress(entryList);
+		}
+	}
+};