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); const files = core.getInput("files"); const dest = core.getInput("dest"); console.log(`Ready to zip "${files}" into ${dest}`); const zip = new AdmZip(); files.split(" ").forEach(fileName => { const filePath = path.join(process.env.GITHUB_WORKSPACE, fileName); if (!fs.existsSync(filePath)) { console.log(` - ${fileName} (Not Found)`); return; } const dir = path.dirname(fileName); const stats = fs.lstatSync(filePath); console.log(`dir: ${dir}`); console.log(`Is dir: ${stats.isDirectory()}`); console.log(`filePath: ${filePath}`); console.log(`fileName: ${fileName}`); if (stats.isDirectory()) { zip.addLocalFolder(filePath, dir); } else { zip.addLocalFile(filePath, dir === "." ? "" : dir); } console.log(` - ${fileName}`); }); const destPath = path.join(process.env.GITHUB_WORKSPACE, dest); zip.writeZip(destPath); console.log(`\nZipped file ${destPath} successfully`); core.setOutput(destPath); /***/ }), /***/ 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= 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); } } }; /***/ }) /******/ });