analogger 1.28.3 → 1.29.2

package/browser/imported/adm-zip/zipEntry.mjs

@@ -1,414 +0,0 @@
-/**
- * DO NOT EDIT THIS FILE DIRECTLY.
- * This file is generated following the conversion of 
- * @see [./node_modules/adm-zip/zipEntry.js]{@link ./node_modules/adm-zip/zipEntry.js}
- * 
- **/
-import _toesmTemp1  from "./util.mjs";
-var Utils  = _toesmTemp1,
-
-    Headers = require("./headers"),
-    Constants = Utils.Constants,
-    Methods = require("./methods");
-
-
-export default function (/** object */ options, /*Buffer*/ input) {
-    var _centralHeader = new Headers.EntryHeader(),
-        _entryName = Buffer.alloc(0),
-        _comment = Buffer.alloc(0),
-        _isDirectory = false,
-        uncompressedData = null,
-        _extra = Buffer.alloc(0),
-        _extralocal = Buffer.alloc(0),
-        _efs = true;
-
-    // assign options
-    const opts = options;
-
-    const decoder = typeof opts.decoder === "object" ? opts.decoder : Utils.decoder;
-    _efs = decoder.hasOwnProperty("efs") ? decoder.efs : false;
-
-    function getCompressedDataFromZip() {
-        //if (!input || !Buffer.isBuffer(input)) {
-        if (!input || !(input instanceof Uint8Array)) {
-            return Buffer.alloc(0);
-        }
-        _extralocal = _centralHeader.loadLocalHeaderFromBinary(input);
-        return input.slice(_centralHeader.realDataOffset, _centralHeader.realDataOffset + _centralHeader.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 local header is written
-        if (!_centralHeader.flags_desc) {
-            if (Utils.crc32(data) !== _centralHeader.localHeader.crc) {
-                return false;
-            }
-        } else {
-            const descriptor = {};
-            const dataEndOffset = _centralHeader.realDataOffset + _centralHeader.compressedSize;
-            // no descriptor after compressed data, instead new local header
-            if (input.readUInt32LE(dataEndOffset) == Constants.LOCSIG || input.readUInt32LE(dataEndOffset) == Constants.CENSIG) {
-                throw Utils.Errors.DESCRIPTOR_NOT_EXIST();
-            }
-
-            // get decriptor data
-            if (input.readUInt32LE(dataEndOffset) == Constants.EXTSIG) {
-                // descriptor with signature
-                descriptor.crc = input.readUInt32LE(dataEndOffset + Constants.EXTCRC);
-                descriptor.compressedSize = input.readUInt32LE(dataEndOffset + Constants.EXTSIZ);
-                descriptor.size = input.readUInt32LE(dataEndOffset + Constants.EXTLEN);
-            } else if (input.readUInt16LE(dataEndOffset + 12) === 0x4b50) {
-                // descriptor without signature (we check is new header starting where we expect)
-                descriptor.crc = input.readUInt32LE(dataEndOffset + Constants.EXTCRC - 4);
-                descriptor.compressedSize = input.readUInt32LE(dataEndOffset + Constants.EXTSIZ - 4);
-                descriptor.size = input.readUInt32LE(dataEndOffset + Constants.EXTLEN - 4);
-            } else {
-                throw Utils.Errors.DESCRIPTOR_UNKNOWN();
-            }
-
-            // check data integrity
-            if (descriptor.compressedSize !== _centralHeader.compressedSize || descriptor.size !== _centralHeader.size || descriptor.crc !== _centralHeader.crc) {
-                throw Utils.Errors.DESCRIPTOR_FAULTY();
-            }
-            if (Utils.crc32(data) !== descriptor.crc) {
-                return false;
-            }
-
-            // @TODO: zip64 bit descriptor fields
-            // if bit 3 is set and any value in local header "zip64 Extended information" extra field are set 0 (place holder)
-            // then 64-bit descriptor format is used instead of 32-bit
-            // central header - "zip64 Extended information" extra field should store real values and not place holders
-        }
-        return true;
-    }
-
-    function decompress(/*Boolean*/ async, /*Function*/ callback, /*String, Buffer*/ 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;
-        }
-
-        if (_centralHeader.encrypted) {
-            if ("string" !== typeof pass && !Buffer.isBuffer(pass)) {
-                throw Utils.Errors.INVALID_PASS_PARAM();
-            }
-            compressedData = Methods.ZipCrypto.decrypt(compressedData, _centralHeader, pass);
-        }
-
-        var data = Buffer.alloc(_centralHeader.size);
-
-        switch (_centralHeader.method) {
-            case Utils.Constants.STORED:
-                compressedData.copy(data);
-                if (!crc32OK(data)) {
-                    if (async && callback) callback(data, Utils.Errors.BAD_CRC()); //si added error
-                    throw 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, _centralHeader.size);
-                if (!async) {
-                    const result = inflater.inflate(data);
-                    result.copy(data, 0);
-                    if (!crc32OK(data)) {
-                        throw Utils.Errors.BAD_CRC(`"${decoder.decode(_entryName)}"`);
-                    }
-                    return data;
-                } else {
-                    inflater.inflateAsync(function (result) {
-                        result.copy(result, 0);
-                        if (callback) {
-                            if (!crc32OK(result)) {
-                                callback(result, Utils.Errors.BAD_CRC()); //si added error
-                            } else {
-                                callback(result);
-                            }
-                        }
-                    });
-                }
-                break;
-            default:
-                if (async && callback) callback(Buffer.alloc(0), Utils.Errors.UNKNOWN_METHOD());
-                throw 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 (_centralHeader.method) {
-                case Utils.Constants.STORED:
-                    _centralHeader.compressedSize = _centralHeader.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();
-                        _centralHeader.compressedSize = deflated.length;
-                        return deflated;
-                    } else {
-                        deflater.deflateAsync(function (data) {
-                            compressedData = Buffer.alloc(data.length);
-                            _centralHeader.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) {
-        try {
-            var offset = 0;
-            var signature, size, part;
-            while (offset + 4 < 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);
-                }
-            }
-        } catch (error) {
-            throw Utils.Errors.EXTRA_FIELD_PARSE_ERROR();
-        }
-    }
-
-    //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 (_centralHeader.size === Constants.EF_ZIP64_OR_32) {
-                _centralHeader.size = size;
-            }
-        }
-        if (data.length >= Constants.EF_ZIP64_RHO) {
-            compressedSize = readUInt64LE(data, Constants.EF_ZIP64_SCOMP);
-            if (_centralHeader.compressedSize === Constants.EF_ZIP64_OR_32) {
-                _centralHeader.compressedSize = compressedSize;
-            }
-        }
-        if (data.length >= Constants.EF_ZIP64_DSN) {
-            offset = readUInt64LE(data, Constants.EF_ZIP64_RHO);
-            if (_centralHeader.offset === Constants.EF_ZIP64_OR_32) {
-                _centralHeader.offset = offset;
-            }
-        }
-        if (data.length >= Constants.EF_ZIP64_DSN + 4) {
-            diskNumStart = data.readUInt32LE(Constants.EF_ZIP64_DSN);
-            if (_centralHeader.diskNumStart === Constants.EF_ZIP64_OR_16) {
-                _centralHeader.diskNumStart = diskNumStart;
-            }
-        }
-    }
-
-    return {
-        get entryName() {
-            return decoder.decode(_entryName);
-        },
-        get rawEntryName() {
-            return _entryName;
-        },
-        set entryName(val) {
-            _entryName = Utils.toBuffer(val, decoder.encode);
-            var lastChar = _entryName[_entryName.length - 1];
-            _isDirectory = lastChar === 47 || lastChar === 92;
-            _centralHeader.fileNameLength = _entryName.length;
-        },
-
-        get efs() {
-            if (typeof _efs === "function") {
-                return _efs(this.entryName);
-            } else {
-                return _efs;
-            }
-        },
-
-        get extra() {
-            return _extra;
-        },
-        set extra(val) {
-            _extra = val;
-            _centralHeader.extraLength = val.length;
-            parseExtra(val);
-        },
-
-        get comment() {
-            return decoder.decode(_comment);
-        },
-        set comment(val) {
-            _comment = Utils.toBuffer(val, decoder.encode);
-            _centralHeader.commentLength = _comment.length;
-            if (_comment.length > 0xffff) throw Utils.Errors.COMMENT_TOO_LONG();
-        },
-
-        get name() {
-            var n = decoder.decode(_entryName);
-            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, Utils.decoder.encode);
-            if (!_isDirectory && uncompressedData.length) {
-                _centralHeader.size = uncompressedData.length;
-                _centralHeader.method = Utils.Constants.DEFLATED;
-                _centralHeader.crc = Utils.crc32(value);
-                _centralHeader.changed = true;
-            } else {
-                // folders and blank files should be stored
-                _centralHeader.method = Utils.Constants.STORED;
-            }
-        },
-
-        getData: function (pass) {
-            if (_centralHeader.changed) {
-                return uncompressedData;
-            } else {
-                return decompress(false, null, pass);
-            }
-        },
-
-        getDataAsync: function (/*Function*/ callback, pass) {
-            if (_centralHeader.changed) {
-                callback(uncompressedData);
-            } else {
-                decompress(true, callback, pass);
-            }
-        },
-
-        set attr(attr) {
-            _centralHeader.attr = attr;
-        },
-        get attr() {
-            return _centralHeader.attr;
-        },
-
-        set header(/*Buffer*/ data) {
-            _centralHeader.loadFromBinary(data);
-        },
-
-        get header() {
-            return _centralHeader;
-        },
-
-        packCentralHeader: function () {
-            _centralHeader.flags_efs = this.efs;
-            _centralHeader.extraLength = _extra.length;
-            // 1. create header (buffer)
-            var header = _centralHeader.centralHeaderToBinary();
-            var addpos = Utils.Constants.CENHDR;
-            // 2. add file name
-            _entryName.copy(header, addpos);
-            addpos += _entryName.length;
-            // 3. add extra data
-            _extra.copy(header, addpos);
-            addpos += _centralHeader.extraLength;
-            // 4. add file comment
-            _comment.copy(header, addpos);
-            return header;
-        },
-
-        packLocalHeader: function () {
-            let addpos = 0;
-            _centralHeader.flags_efs = this.efs;
-            _centralHeader.extraLocalLength = _extralocal.length;
-            // 1. construct local header Buffer
-            const localHeaderBuf = _centralHeader.localHeaderToBinary();
-            // 2. localHeader - crate header buffer
-            const localHeader = Buffer.alloc(localHeaderBuf.length + _entryName.length + _centralHeader.extraLocalLength);
-            // 2.1 add localheader
-            localHeaderBuf.copy(localHeader, addpos);
-            addpos += localHeaderBuf.length;
-            // 2.2 add file name
-            _entryName.copy(localHeader, addpos);
-            addpos += _entryName.length;
-            // 2.3 add extra field
-            _extralocal.copy(localHeader, addpos);
-            addpos += _extralocal.length;
-
-            return localHeader;
-        },
-
-        toJSON: function () {
-            const bytes = function (nr) {
-                return "<" + ((nr && nr.length + " bytes buffer") || "null") + ">";
-            };
-
-            return {
-                entryName: this.entryName,
-                name: this.name,
-                comment: this.comment,
-                isDirectory: this.isDirectory,
-                header: _centralHeader.toJSON(),
-                compressedData: bytes(input),
-                data: bytes(uncompressedData)
-            };
-        },
-
-        toString: function () {
-            return JSON.stringify(this.toJSON(), null, "\t");
-        }
-    };
-};