2020-03-21 04:41:59 -07:00
|
|
|
module.exports =
|
|
|
|
|
/******/ (function(modules, runtime) { // webpackBootstrap
|
|
|
|
|
/******/ "use strict";
|
|
|
|
|
/******/ // The module cache
|
|
|
|
|
/******/ var installedModules = {};
|
|
|
|
|
/******/
|
|
|
|
|
/******/ // The require function
|
|
|
|
|
/******/ function __webpack_require__(moduleId) {
|
|
|
|
|
/******/
|
|
|
|
|
/******/ // Check if module is in cache
|
|
|
|
|
/******/ if(installedModules[moduleId]) {
|
|
|
|
|
/******/ return installedModules[moduleId].exports;
|
|
|
|
|
/******/ }
|
|
|
|
|
/******/ // Create a new module (and put it into the cache)
|
|
|
|
|
/******/ var module = installedModules[moduleId] = {
|
|
|
|
|
/******/ i: moduleId,
|
|
|
|
|
/******/ l: false,
|
|
|
|
|
/******/ exports: {}
|
|
|
|
|
/******/ };
|
|
|
|
|
/******/
|
|
|
|
|
/******/ // Execute the module function
|
|
|
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
|
|
|
/******/
|
|
|
|
|
/******/ // Flag the module as loaded
|
|
|
|
|
/******/ module.l = true;
|
|
|
|
|
/******/
|
|
|
|
|
/******/ // Return the exports of the module
|
|
|
|
|
/******/ return module.exports;
|
|
|
|
|
/******/ }
|
|
|
|
|
/******/
|
|
|
|
|
/******/
|
|
|
|
|
/******/ __webpack_require__.ab = __dirname + "/";
|
|
|
|
|
/******/
|
|
|
|
|
/******/ // the startup function
|
|
|
|
|
/******/ function startup() {
|
|
|
|
|
/******/ // Load entry module and return exports
|
|
|
|
|
/******/ return __webpack_require__(104);
|
|
|
|
|
/******/ };
|
|
|
|
|
/******/
|
|
|
|
|
/******/ // run startup
|
|
|
|
|
/******/ return startup();
|
|
|
|
|
/******/ })
|
|
|
|
|
/************************************************************************/
|
|
|
|
|
/******/ ({
|
|
|
|
|
|
|
|
|
|
/***/ 87:
|
|
|
|
|
/***/ (function(module) {
|
|
|
|
|
|
|
|
|
|
module.exports = require("os");
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 104:
|
|
|
|
|
/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) {
|
|
|
|
|
|
|
|
|
|
const fs = __webpack_require__(747);
|
|
|
|
|
const path = __webpack_require__(622);
|
|
|
|
|
const AdmZip = __webpack_require__(639);
|
|
|
|
|
const core = __webpack_require__(470);
|
|
|
|
|
|
2020-03-21 05:20:56 -07:00
|
|
|
const files = core.getInput("files");
|
|
|
|
|
const dest = core.getInput("dest");
|
2020-03-21 06:46:00 -07:00
|
|
|
const recursive = core.getInput("recursive") === "true";
|
2020-03-21 04:41:59 -07:00
|
|
|
|
2020-03-21 05:20:56 -07:00
|
|
|
console.log(`Ready to zip "${files}" into ${dest}`);
|
2020-03-21 04:41:59 -07:00
|
|
|
|
2020-03-21 05:08:23 -07:00
|
|
|
const zip = new AdmZip();
|
2020-03-21 04:46:09 -07:00
|
|
|
|
2020-03-21 05:20:56 -07:00
|
|
|
files.split(" ").forEach(fileName => {
|
|
|
|
|
const filePath = path.join(process.env.GITHUB_WORKSPACE, fileName);
|
2020-03-21 05:08:23 -07:00
|
|
|
|
2020-03-21 05:20:56 -07:00
|
|
|
if (!fs.existsSync(filePath)) {
|
|
|
|
|
console.log(` - ${fileName} (Not Found)`);
|
2020-03-21 04:41:59 -07:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-21 05:20:56 -07:00
|
|
|
const dir = path.dirname(fileName);
|
|
|
|
|
const stats = fs.lstatSync(filePath);
|
2020-03-21 04:41:59 -07:00
|
|
|
|
|
|
|
|
if (stats.isDirectory()) {
|
2020-03-21 06:46:00 -07:00
|
|
|
const zipDir = dir === "." ? fileName : dir;
|
|
|
|
|
zip.addLocalFolder(filePath, !recursive && zipDir);
|
2020-03-21 04:41:59 -07:00
|
|
|
} else {
|
2020-03-21 06:46:00 -07:00
|
|
|
const zipDir = dir === "." ? "" : dir;
|
|
|
|
|
zip.addLocalFile(filePath, !recursive && zipDir);
|
2020-03-21 04:41:59 -07:00
|
|
|
}
|
|
|
|
|
|
2020-03-21 05:20:56 -07:00
|
|
|
console.log(` - ${fileName}`);
|
2020-03-21 04:41:59 -07:00
|
|
|
});
|
|
|
|
|
|
2020-03-21 05:20:56 -07:00
|
|
|
const destPath = path.join(process.env.GITHUB_WORKSPACE, dest);
|
|
|
|
|
|
|
|
|
|
zip.writeZip(destPath);
|
2020-03-21 04:41:59 -07:00
|
|
|
|
2020-03-21 05:33:59 -07:00
|
|
|
console.log(`\nZipped file ${dest} successfully`);
|
2020-03-21 04:41:59 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 181:
|
|
|
|
|
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
|
|
|
|
|
|
|
|
|
exports.EntryHeader = __webpack_require__(239);
|
|
|
|
|
exports.MainHeader = __webpack_require__(602);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 239:
|
|
|
|
|
/***/ (function(module, __unusedexports, __webpack_require__) {
|
|
|
|
|
|
|
|
|
|
var Utils = __webpack_require__(643),
|
|
|
|
|
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 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 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" +
|
|
|
|
|
'}';
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 307:
|
|
|
|
|
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
|
|
|
|
|
|
|
|
|
exports.require = function() {
|
|
|
|
|
var fs = __webpack_require__(747);
|
|
|
|
|
if (process.versions['electron']) {
|
|
|
|
|
try {
|
|
|
|
|
originalFs = __webpack_require__(708);
|
|
|
|
|
if (Object.keys(originalFs).length > 0) {
|
|
|
|
|
fs = originalFs;
|
|
|
|
|
}
|
|
|
|
|
} catch (e) {}
|
|
|
|
|
}
|
|
|
|
|
return fs
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 352:
|
|
|
|
|
/***/ (function(module, __unusedexports, __webpack_require__) {
|
|
|
|
|
|
|
|
|
|
var Utils = __webpack_require__(643),
|
|
|
|
|
Headers = __webpack_require__(181),
|
|
|
|
|
Constants = Utils.Constants,
|
|
|
|
|
Methods = __webpack_require__(880);
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
return 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)) {
|
|
|
|
|
console.warn(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);
|
|
|
|
|
return 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" +
|
|
|
|
|
'}';
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 385:
|
|
|
|
|
/***/ (function(module, __unusedexports, __webpack_require__) {
|
|
|
|
|
|
|
|
|
|
var ZipEntry = __webpack_require__(352),
|
|
|
|
|
Headers = __webpack_require__(181),
|
|
|
|
|
Utils = __webpack_require__(643);
|
|
|
|
|
|
|
|
|
|
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 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) {
|
|
|
|
|
_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);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 431:
|
|
|
|
|
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
|
|
|
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
|
var __importStar = (this && this.__importStar) || function (mod) {
|
|
|
|
|
if (mod && mod.__esModule) return mod;
|
|
|
|
|
var result = {};
|
|
|
|
|
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
|
|
|
|
result["default"] = mod;
|
|
|
|
|
return result;
|
|
|
|
|
};
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
|
|
const os = __importStar(__webpack_require__(87));
|
|
|
|
|
/**
|
|
|
|
|
* Commands
|
|
|
|
|
*
|
|
|
|
|
* Command Format:
|
|
|
|
|
* ::name key=value,key=value::message
|
|
|
|
|
*
|
|
|
|
|
* Examples:
|
|
|
|
|
* ::warning::This is the message
|
|
|
|
|
* ::set-env name=MY_VAR::some value
|
|
|
|
|
*/
|
|
|
|
|
function issueCommand(command, properties, message) {
|
|
|
|
|
const cmd = new Command(command, properties, message);
|
|
|
|
|
process.stdout.write(cmd.toString() + os.EOL);
|
|
|
|
|
}
|
|
|
|
|
exports.issueCommand = issueCommand;
|
|
|
|
|
function issue(name, message = '') {
|
|
|
|
|
issueCommand(name, {}, message);
|
|
|
|
|
}
|
|
|
|
|
exports.issue = issue;
|
|
|
|
|
const CMD_STRING = '::';
|
|
|
|
|
class Command {
|
|
|
|
|
constructor(command, properties, message) {
|
|
|
|
|
if (!command) {
|
|
|
|
|
command = 'missing.command';
|
|
|
|
|
}
|
|
|
|
|
this.command = command;
|
|
|
|
|
this.properties = properties;
|
|
|
|
|
this.message = message;
|
|
|
|
|
}
|
|
|
|
|
toString() {
|
|
|
|
|
let cmdStr = CMD_STRING + this.command;
|
|
|
|
|
if (this.properties && Object.keys(this.properties).length > 0) {
|
|
|
|
|
cmdStr += ' ';
|
|
|
|
|
let first = true;
|
|
|
|
|
for (const key in this.properties) {
|
|
|
|
|
if (this.properties.hasOwnProperty(key)) {
|
|
|
|
|
const val = this.properties[key];
|
|
|
|
|
if (val) {
|
|
|
|
|
if (first) {
|
|
|
|
|
first = false;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
cmdStr += ',';
|
|
|
|
|
}
|
|
|
|
|
cmdStr += `${key}=${escapeProperty(val)}`;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
|
|
|
|
|
return cmdStr;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
function escapeData(s) {
|
|
|
|
|
return (s || '')
|
|
|
|
|
.replace(/%/g, '%25')
|
|
|
|
|
.replace(/\r/g, '%0D')
|
|
|
|
|
.replace(/\n/g, '%0A');
|
|
|
|
|
}
|
|
|
|
|
function escapeProperty(s) {
|
|
|
|
|
return (s || '')
|
|
|
|
|
.replace(/%/g, '%25')
|
|
|
|
|
.replace(/\r/g, '%0D')
|
|
|
|
|
.replace(/\n/g, '%0A')
|
|
|
|
|
.replace(/:/g, '%3A')
|
|
|
|
|
.replace(/,/g, '%2C');
|
|
|
|
|
}
|
|
|
|
|
//# sourceMappingURL=command.js.map
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 470:
|
|
|
|
|
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
|
|
|
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
|
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
|
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
|
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
|
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
|
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
|
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
var __importStar = (this && this.__importStar) || function (mod) {
|
|
|
|
|
if (mod && mod.__esModule) return mod;
|
|
|
|
|
var result = {};
|
|
|
|
|
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
|
|
|
|
result["default"] = mod;
|
|
|
|
|
return result;
|
|
|
|
|
};
|
|
|
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
|
|
const command_1 = __webpack_require__(431);
|
|
|
|
|
const os = __importStar(__webpack_require__(87));
|
|
|
|
|
const path = __importStar(__webpack_require__(622));
|
|
|
|
|
/**
|
|
|
|
|
* The code to exit an action
|
|
|
|
|
*/
|
|
|
|
|
var ExitCode;
|
|
|
|
|
(function (ExitCode) {
|
|
|
|
|
/**
|
|
|
|
|
* A code indicating that the action was successful
|
|
|
|
|
*/
|
|
|
|
|
ExitCode[ExitCode["Success"] = 0] = "Success";
|
|
|
|
|
/**
|
|
|
|
|
* A code indicating that the action was a failure
|
|
|
|
|
*/
|
|
|
|
|
ExitCode[ExitCode["Failure"] = 1] = "Failure";
|
|
|
|
|
})(ExitCode = exports.ExitCode || (exports.ExitCode = {}));
|
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
|
// Variables
|
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
|
/**
|
|
|
|
|
* Sets env variable for this action and future actions in the job
|
|
|
|
|
* @param name the name of the variable to set
|
|
|
|
|
* @param val the value of the variable
|
|
|
|
|
*/
|
|
|
|
|
function exportVariable(name, val) {
|
|
|
|
|
process.env[name] = val;
|
|
|
|
|
command_1.issueCommand('set-env', { name }, val);
|
|
|
|
|
}
|
|
|
|
|
exports.exportVariable = exportVariable;
|
|
|
|
|
/**
|
|
|
|
|
* Registers a secret which will get masked from logs
|
|
|
|
|
* @param secret value of the secret
|
|
|
|
|
*/
|
|
|
|
|
function setSecret(secret) {
|
|
|
|
|
command_1.issueCommand('add-mask', {}, secret);
|
|
|
|
|
}
|
|
|
|
|
exports.setSecret = setSecret;
|
|
|
|
|
/**
|
|
|
|
|
* Prepends inputPath to the PATH (for this action and future actions)
|
|
|
|
|
* @param inputPath
|
|
|
|
|
*/
|
|
|
|
|
function addPath(inputPath) {
|
|
|
|
|
command_1.issueCommand('add-path', {}, inputPath);
|
|
|
|
|
process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
|
|
|
|
|
}
|
|
|
|
|
exports.addPath = addPath;
|
|
|
|
|
/**
|
|
|
|
|
* Gets the value of an input. The value is also trimmed.
|
|
|
|
|
*
|
|
|
|
|
* @param name name of the input to get
|
|
|
|
|
* @param options optional. See InputOptions.
|
|
|
|
|
* @returns string
|
|
|
|
|
*/
|
|
|
|
|
function getInput(name, options) {
|
|
|
|
|
const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || '';
|
|
|
|
|
if (options && options.required && !val) {
|
|
|
|
|
throw new Error(`Input required and not supplied: ${name}`);
|
|
|
|
|
}
|
|
|
|
|
return val.trim();
|
|
|
|
|
}
|
|
|
|
|
exports.getInput = getInput;
|
|
|
|
|
/**
|
|
|
|
|
* Sets the value of an output.
|
|
|
|
|
*
|
|
|
|
|
* @param name name of the output to set
|
|
|
|
|
* @param value value to store
|
|
|
|
|
*/
|
|
|
|
|
function setOutput(name, value) {
|
|
|
|
|
command_1.issueCommand('set-output', { name }, value);
|
|
|
|
|
}
|
|
|
|
|
exports.setOutput = setOutput;
|
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
|
// Results
|
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
|
/**
|
|
|
|
|
* Sets the action status to failed.
|
|
|
|
|
* When the action exits it will be with an exit code of 1
|
|
|
|
|
* @param message add error issue message
|
|
|
|
|
*/
|
|
|
|
|
function setFailed(message) {
|
|
|
|
|
process.exitCode = ExitCode.Failure;
|
|
|
|
|
error(message);
|
|
|
|
|
}
|
|
|
|
|
exports.setFailed = setFailed;
|
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
|
// Logging Commands
|
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
|
/**
|
|
|
|
|
* Gets whether Actions Step Debug is on or not
|
|
|
|
|
*/
|
|
|
|
|
function isDebug() {
|
|
|
|
|
return process.env['RUNNER_DEBUG'] === '1';
|
|
|
|
|
}
|
|
|
|
|
exports.isDebug = isDebug;
|
|
|
|
|
/**
|
|
|
|
|
* Writes debug message to user log
|
|
|
|
|
* @param message debug message
|
|
|
|
|
*/
|
|
|
|
|
function debug(message) {
|
|
|
|
|
command_1.issueCommand('debug', {}, message);
|
|
|
|
|
}
|
|
|
|
|
exports.debug = debug;
|
|
|
|
|
/**
|
|
|
|
|
* Adds an error issue
|
|
|
|
|
* @param message error issue message
|
|
|
|
|
*/
|
|
|
|
|
function error(message) {
|
|
|
|
|
command_1.issue('error', message);
|
|
|
|
|
}
|
|
|
|
|
exports.error = error;
|
|
|
|
|
/**
|
|
|
|
|
* Adds an warning issue
|
|
|
|
|
* @param message warning issue message
|
|
|
|
|
*/
|
|
|
|
|
function warning(message) {
|
|
|
|
|
command_1.issue('warning', message);
|
|
|
|
|
}
|
|
|
|
|
exports.warning = warning;
|
|
|
|
|
/**
|
|
|
|
|
* Writes info to log with console.log.
|
|
|
|
|
* @param message info message
|
|
|
|
|
*/
|
|
|
|
|
function info(message) {
|
|
|
|
|
process.stdout.write(message + os.EOL);
|
|
|
|
|
}
|
|
|
|
|
exports.info = info;
|
|
|
|
|
/**
|
|
|
|
|
* Begin an output group.
|
|
|
|
|
*
|
|
|
|
|
* Output until the next `groupEnd` will be foldable in this group
|
|
|
|
|
*
|
|
|
|
|
* @param name The name of the output group
|
|
|
|
|
*/
|
|
|
|
|
function startGroup(name) {
|
|
|
|
|
command_1.issue('group', name);
|
|
|
|
|
}
|
|
|
|
|
exports.startGroup = startGroup;
|
|
|
|
|
/**
|
|
|
|
|
* End an output group.
|
|
|
|
|
*/
|
|
|
|
|
function endGroup() {
|
|
|
|
|
command_1.issue('endgroup');
|
|
|
|
|
}
|
|
|
|
|
exports.endGroup = endGroup;
|
|
|
|
|
/**
|
|
|
|
|
* Wrap an asynchronous function call in a group.
|
|
|
|
|
*
|
|
|
|
|
* Returns the same type as the function itself.
|
|
|
|
|
*
|
|
|
|
|
* @param name The name of the group
|
|
|
|
|
* @param fn The function to wrap in the group
|
|
|
|
|
*/
|
|
|
|
|
function group(name, fn) {
|
|
|
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
|
|
|
startGroup(name);
|
|
|
|
|
let result;
|
|
|
|
|
try {
|
|
|
|
|
result = yield fn();
|
|
|
|
|
}
|
|
|
|
|
finally {
|
|
|
|
|
endGroup();
|
|
|
|
|
}
|
|
|
|
|
return result;
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
exports.group = group;
|
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
|
// Wrapper action state
|
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
|
/**
|
|
|
|
|
* Saves state for current action, the state can only be retrieved by this action's post job execution.
|
|
|
|
|
*
|
|
|
|
|
* @param name name of the state to store
|
|
|
|
|
* @param value value to store
|
|
|
|
|
*/
|
|
|
|
|
function saveState(name, value) {
|
|
|
|
|
command_1.issueCommand('save-state', { name }, value);
|
|
|
|
|
}
|
|
|
|
|
exports.saveState = saveState;
|
|
|
|
|
/**
|
|
|
|
|
* Gets the value of an state set by this action's main execution.
|
|
|
|
|
*
|
|
|
|
|
* @param name name of the state to get
|
|
|
|
|
* @returns string
|
|
|
|
|
*/
|
|
|
|
|
function getState(name) {
|
|
|
|
|
return process.env[`STATE_${name}`] || '';
|
|
|
|
|
}
|
|
|
|
|
exports.getState = getState;
|
|
|
|
|
//# sourceMappingURL=core.js.map
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 474:
|
|
|
|
|
/***/ (function(module, __unusedexports, __webpack_require__) {
|
|
|
|
|
|
|
|
|
|
module.exports = function (/*Buffer*/inbuf) {
|
|
|
|
|
|
|
|
|
|
var zlib = __webpack_require__(761);
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 553:
|
|
|
|
|
/***/ (function(module) {
|
|
|
|
|
|
|
|
|
|
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"
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 591:
|
|
|
|
|
/***/ (function(module, __unusedexports, __webpack_require__) {
|
|
|
|
|
|
|
|
|
|
var fs = __webpack_require__(307).require(),
|
|
|
|
|
pth = __webpack_require__(622);
|
|
|
|
|
|
|
|
|
|
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" +
|
|
|
|
|
'}';
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 602:
|
|
|
|
|
/***/ (function(module, __unusedexports, __webpack_require__) {
|
|
|
|
|
|
|
|
|
|
var Utils = __webpack_require__(643),
|
|
|
|
|
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 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" +
|
|
|
|
|
'}';
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 622:
|
|
|
|
|
/***/ (function(module) {
|
|
|
|
|
|
|
|
|
|
module.exports = require("path");
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 626:
|
|
|
|
|
/***/ (function(module, __unusedexports, __webpack_require__) {
|
|
|
|
|
|
|
|
|
|
var fs = __webpack_require__(307).require(),
|
|
|
|
|
pth = __webpack_require__(622);
|
|
|
|
|
|
|
|
|
|
fs.existsSync = fs.existsSync || pth.existsSync;
|
|
|
|
|
|
|
|
|
|
module.exports = (function() {
|
|
|
|
|
|
|
|
|
|
var crcTable = [],
|
|
|
|
|
Constants = __webpack_require__(799),
|
|
|
|
|
Errors = __webpack_require__(553),
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
}
|
|
|
|
|
})();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 639:
|
|
|
|
|
/***/ (function(module, __unusedexports, __webpack_require__) {
|
|
|
|
|
|
|
|
|
|
var Utils = __webpack_require__(643);
|
|
|
|
|
var fs = Utils.FileSystem.require(),
|
|
|
|
|
pth = __webpack_require__(622);
|
|
|
|
|
|
|
|
|
|
fs.existsSync = fs.existsSync || pth.existsSync;
|
|
|
|
|
|
|
|
|
|
var ZipEntry = __webpack_require__(352),
|
|
|
|
|
ZipFile = __webpack_require__(385);
|
|
|
|
|
|
|
|
|
|
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 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 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 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 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 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 Utils.Errors.CANT_EXTRACT_FILE;
|
|
|
|
|
|
|
|
|
|
if (fs.existsSync(target) && !overwrite) {
|
|
|
|
|
throw 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 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 Utils.Errors.CANT_EXTRACT_FILE;
|
|
|
|
|
}
|
|
|
|
|
Utils.writeFileTo(entryName, content, overwrite);
|
|
|
|
|
try {
|
|
|
|
|
fs.utimesSync(entryName, entry.header.time, entry.header.time)
|
|
|
|
|
} catch (err) {
|
|
|
|
|
throw 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()
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 643:
|
|
|
|
|
/***/ (function(module, __unusedexports, __webpack_require__) {
|
|
|
|
|
|
|
|
|
|
module.exports = __webpack_require__(626);
|
|
|
|
|
module.exports.FileSystem = __webpack_require__(307);
|
|
|
|
|
module.exports.Constants = __webpack_require__(799);
|
|
|
|
|
module.exports.Errors = __webpack_require__(553);
|
|
|
|
|
module.exports.FileAttr = __webpack_require__(591);
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 708:
|
|
|
|
|
/***/ (function() {
|
|
|
|
|
|
|
|
|
|
eval("require")("original-fs");
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 747:
|
|
|
|
|
/***/ (function(module) {
|
|
|
|
|
|
|
|
|
|
module.exports = require("fs");
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 761:
|
|
|
|
|
/***/ (function(module) {
|
|
|
|
|
|
|
|
|
|
module.exports = require("zlib");
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 799:
|
|
|
|
|
/***/ (function(module) {
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 880:
|
|
|
|
|
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
|
|
|
|
|
|
|
|
|
exports.Deflater = __webpack_require__(474);
|
|
|
|
|
exports.Inflater = __webpack_require__(937);
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 937:
|
|
|
|
|
/***/ (function(module, __unusedexports, __webpack_require__) {
|
|
|
|
|
|
|
|
|
|
module.exports = function (/*Buffer*/inbuf) {
|
|
|
|
|
|
|
|
|
|
var zlib = __webpack_require__(761);
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ })
|
|
|
|
|
|
|
|
|
|
/******/ });
|
