pax_global_header00006660000000000000000000000064152112651610014512gustar00rootroot0000000000000052 comment=f5798e15204ffbb9a428b00217e4659684a41b0f yauzl-3.4.0/000077500000000000000000000000001521126516100126625ustar00rootroot00000000000000yauzl-3.4.0/.github/000077500000000000000000000000001521126516100142225ustar00rootroot00000000000000yauzl-3.4.0/.github/workflows/000077500000000000000000000000001521126516100162575ustar00rootroot00000000000000yauzl-3.4.0/.github/workflows/test.yml000066400000000000000000000010111521126516100177520ustar00rootroot00000000000000on: push: branches: - master pull_request: branches: - master jobs: test: strategy: matrix: node-version: - 12 - 14 - 16 - 18 - 20 - 24 - 26 runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Use Node.js ${{ matrix.node-version }} uses: actions/setup-node@v4 with: node-version: ${{ matrix.node-version }} - run: npm install - run: node test/test.js yauzl-3.4.0/.gitignore000066400000000000000000000000431521126516100146470ustar00rootroot00000000000000/coverage /node_modules /test/.tmp yauzl-3.4.0/CONTRIBUTING.md000066400000000000000000000051111521126516100151110ustar00rootroot00000000000000# Contributing to yauzl ## Intro Thanks for your interest in contributing to this project! I'm a team of one person reviewing issues and PRs and publishing updates to this code. I appreciate your patience, as I might take weeks-to-months to respond. This project is "funded" strictly by my enthusiasm, and many aspects of its design are optimized for maintainer joy: correctness, precision, test coverage, performance, thoroughly documented API, etc. The best way that you, prospective contributor, can support the project is honestly just having a warm attitude. We're all here making open source software to make the world a better place, and I appreciate you joining me on this journey! ❤️ ## AI Policy Using the model proposed in https://www.visidata.org/blog/2026/ai/ , PRs submitted to this project are limited to Levels 0-5, meaning you need to fully understand everything you are presenting regardless of how it got written. I am always operating at Level 0. I don't have any accounts with AI companies, because LLM-assisted code authoring takes the fun out of it for me. I insist on understanding all the code I ship, and I ask that you respect my level of effort before asking me to review your code. ## When to open an Issue vs a PR Simple typo fixes are pretty trivial to fully understand, but complex fixes or features are much harder. If you don't fully understand the PR you're drafting, consider just filing a bug report or feature request instead. I don't expect you to have full context on this project's history and nuances, so come on over to the issues section and let's discuss it! I'd much prefer you ask for help than propose a change with misplaced confidence in an LLM. Even if you do achieve full understanding of a complex PR, I may review your code and decide to rewrite it all in my own style anyway. That doesn't mean you wasted your time! Showing interest in this project contributes directly to the "funding" mentioned above; I appreciate it! However, if you don't like the idea of your code getting thrown away, let's have a design discussion in the issues before you invest your time in any code changes. ## Software engineering fundamentals I won't articulate the fundamentals of how to open good bug reports, feature requests, or change requests in this guide. These are skills that apply to any open source repo, so you should be able to find resources elsewhere (for example, bug reports should include steps to reproduce). If you wish there were helpful links listed here and you've found some you like, feel free to open an issue or PR with suggestions! ## Thank You! -Josh yauzl-3.4.0/LICENSE000066400000000000000000000020651521126516100136720ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2014 Josh Wolfe Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. yauzl-3.4.0/README.md000066400000000000000000001553061521126516100141530ustar00rootroot00000000000000# yauzl yet another unzip library for node. For zipping, see [yazl](https://github.com/thejoshwolfe/yazl). Design principles: * Follow the spec. Don't scan for local file headers. Read the central directory for file metadata. (see [No Streaming Unzip API](#no-streaming-unzip-api)). * Don't block the JavaScript thread. Use and provide async APIs. * Keep memory usage under control. Don't attempt to buffer entire files in RAM at once. * Never crash (if used properly). Don't let malformed zip files bring down client applications who are trying to catch errors. * Catch unsafe file names. See `validateFileName()`. ## Usage Using `await`: ```js const yauzl = require("yauzl"); (async () => { try { const zipfile = await yauzl.openPromise("path/to/file.zip"); for await (let entry of zipfile.eachEntry()) { if (entry.fileName.endsWith("/")) { // Directory file names end with '/'. // Note that entries for directories themselves are optional. // An entry's fileName implicitly requires its parent directories to exist. continue; } else { // file entry const readStream = await zipfile.openReadStreamPromise(entry); await stream.promises.pipeline(readStream, somewhere); } } } catch (err) { // Indicates a malformed zipfile or I/O error. throw err; } })(); ``` Using callbacks: ```js var yauzl = require("yauzl"); yauzl.open("path/to/file.zip", {lazyEntries: true}, function(err, zipfile) { if (err) throw err; zipfile.readEntry(); zipfile.on("entry", function(entry) { if (entry.fileName.endsWith("/")) { // Ignore directory entry. zipfile.readEntry(); } else { // file entry zipfile.openReadStream(entry, function(err, readStream) { if (err) throw err; readStream.on("end", function() { zipfile.readEntry(); }); readStream.pipe(somewhere); }); } }); }); ``` See also `examples/` for more usage examples. ## API The default for every optional `callback` parameter is: ```js function defaultCallback(err) { if (err) throw err; } ``` ### open(path, [options], [callback]) Calls `fs.open(path, "r")` and reads the `fd` effectively the same as `fromFd()` would. See also `openPromise()` to get `Promise` semantics. `options` may be omitted or `null`. The defaults are `{autoClose: true, lazyEntries: false, decodeStrings: true, validateEntrySizes: true, strictFileNames: false}`. `autoClose` is effectively equivalent to: ```js zipfile.once("end", function() { zipfile.close(); }); ``` `lazyEntries` indicates that entries should be read only when `readEntry()` is called. If `lazyEntries` is `false`, `entry` events will be emitted as fast as possible to allow `pipe()`ing file data from all entries in parallel. This is not recommended, as it can lead to out of control memory usage for zip files with many entries. See [issue #22](https://github.com/thejoshwolfe/yauzl/issues/22). If `lazyEntries` is `true`, an `entry` or `end` event will be emitted in response to each call to `readEntry()`. This allows processing of one entry at a time, and will keep memory usage under control for zip files with many entries. `decodeStrings` is the default and causes yauzl to decode strings with `CP437` or `UTF-8` as required by the spec. The exact effects of turning this option off are: * `zipfile.comment`, `entry.fileName`, and `entry.fileComment` will be `Buffer` objects instead of `String`s. * Any Info-ZIP Unicode Path Extra Field will be ignored. See `extraFields`. * Automatic file name validation will not be performed. See `validateFileName()`. `validateEntrySizes` is the default and ensures that an entry's reported uncompressed size matches its actual uncompressed size. This check happens as early as possible, which is either before emitting each `"entry"` event (for entries with no compression), or during the `readStream` piping after calling `openReadStream()`. See `openReadStream()` for more information on defending against zip bomb attacks. When `strictFileNames` is `false` (the default) and `decodeStrings` is `true`, all backslash (`\`) characters in each `entry.fileName` are replaced with forward slashes (`/`). The spec forbids file names with backslashes, but Microsoft's `System.IO.Compression.ZipFile` class in .NET versions 4.5.0 until 4.6.1 creates non-conformant zipfiles with backslashes in file names. `strictFileNames` is `false` by default so that clients can read these non-conformant zipfiles without knowing about this Microsoft-specific bug. When `strictFileNames` is `true` and `decodeStrings` is `true`, entries with backslashes in their file names will result in an error. See `validateFileName()`. When `decodeStrings` is `false`, `strictFileNames` has no effect. The `callback` is given the arguments `(err, zipfile)`. An `err` is provided if the End of Central Directory Record cannot be found, or if its metadata appears malformed. This kind of error usually indicates that this is not a zip file. Otherwise, `zipfile` is an instance of `ZipFile`. ### fromFd(fd, [options], [callback]) Reads from the fd, which is presumed to be an open .zip file. Note that random access is required by the zip file specification, so the fd cannot be an open socket or any other fd that does not support random access. See also `fromFdPromise()` to get `Promise` semantics. `options` may be omitted or `null`. The defaults are `{autoClose: false, lazyEntries: false, decodeStrings: true, validateEntrySizes: true, strictFileNames: false}`. See `open()` for the meaning of the options and callback. ### fromBuffer(buffer, [options], [callback]) Like `fromFd()`, but reads from a RAM buffer instead of an open file. `buffer` is a `Buffer`. See also `fromBufferPromise()` to get `Promise` semantics. If a `ZipFile` is acquired from this method, it will never emit the `close` event, and calling `close()` is not necessary. `options` may be omitted or `null`. The defaults are `{lazyEntries: false, decodeStrings: true, validateEntrySizes: true, strictFileNames: false}`. See `open()` for the meaning of the options and callback. The `autoClose` option is ignored for this method. ### fromRandomAccessReader(reader, totalSize, [options], [callback]) This method of reading a zip file allows clients to implement their own back-end file system. For example, a client might translate read calls into network requests. See also `fromRandomAccessReaderPromise()` to get `Promise` semantics. The `reader` parameter must be of a type that is a subclass of [RandomAccessReader](#class-randomaccessreader) that implements the required methods. The `totalSize` is a Number and indicates the total file size of the zip file. `options` may be omitted or `null`. The defaults are `{autoClose: true, lazyEntries: false, decodeStrings: true, validateEntrySizes: true, strictFileNames: false}`. See `open()` for the meaning of the options and callback. ### openPromise(path, [options]) Wraps `open()` with `Promise` semantics. The returned promise is rejected if the `callback` for `open()` receives an `err`, otherwise the promise is resolved with the `zipfile`. `options` may be omitted or `null`, and `path` and `options` are passed to `open()`. `options.lazyEntries` is always set to `true`, overriding any value you pass in. This is required for using `zipfile.eachEntry()`, which you probably also want to use. ### fromFdPromise(fd, [options]) Wraps `fromFd()` with `Promise` semantics. The returned promise is rejected if the `callback` for `fromFd()` receives an `err`, otherwise the promise is resolved with the `zipfile`. `options` may be omitted or `null`, and `fd` and `options` are passed to `fromFd()`. `options.lazyEntries` is always set to `true`, overriding any value you pass in. This is required for using `zipfile.eachEntry()`, which you probably also want to use. ### fromBufferPromise(buffer, [options]) Wraps `fromBuffer()` with `Promise` semantics. The returned promise is rejected if the `callback` for `fromBuffer()` receives an `err`, otherwise the promise is resolved with the `zipfile`. `options` may be omitted or `null`, and `buffer` and `options` are passed to `fromBuffer()`. `options.lazyEntries` is always set to `true`, overriding any value you pass in. This is required for using `zipfile.eachEntry()`, which you probably also want to use. ### fromRandomAccessReaderPromise(reader, totalSize, [options]) Wraps `fromRandomAccessReader()` with `Promise` semantics. The returned promise is rejected if the `callback` for `fromRandomAccessReader()` receives an `err`, otherwise the promise is resolved with the `zipfile`. `options` may be omitted or `null`, and `reader`, `totalSize`, and `options` are passed to `fromRandomAccessReader()`. `options.lazyEntries` is always set to `true`, overriding any value you pass in. This is required for using `zipfile.eachEntry()`, which you probably also want to use. ### dosDateTimeToDate(date, time) *Deprecated*. Since yauzl 3.2.0, it is highly recommended to call [`entry.getLastModDate()`](#getlastmoddateoptions) instead of this function due to enhanced support for reading third-party extra fields. If you ever have a use case for calling this function directly please [open an issue against yauzl](https://github.com/thejoshwolfe/yauzl/issues/new) requesting that this function be properly supported again. This function only remains exported in order to maintain compatibility with older versions of yauzl. It will be removed in yauzl 4.0.0 unless someone asks for it to remain supported. ### getFileNameLowLevel(generalPurposeBitFlag, fileNameBuffer, extraFields, strictFileNames) If you are setting `decodeStrings` to `false`, then this function can be used to decode the file name yourself. This function is effectively used internally by yauzl to populate the `entry.fileName` field when `decodeStrings` is `true`. WARNING: This method of getting the file name bypasses the security checks in [`validateFileName()`](#validatefilename-filename). You should call that function yourself to be sure to guard against malicious file paths. `generalPurposeBitFlag` can be found on an [`Entry`](#class-entry) or [`LocalFileHeader`](#class-localfileheader). Only General Purpose Bit 11 is used, and only when an Info-ZIP Unicode Path Extra Field cannot be found in `extraFields`. `fileNameBuffer` is a `Buffer` representing the file name field of the entry. This is `entry.fileNameRaw` or `localFileHeader.fileName`. `extraFields` is the parsed extra fields array from `entry.extraFields` or `parseExtraFields()`. `strictFileNames` is a boolean, the same as the option of the same name in `open()`. When `false`, backslash characters (`\`) will be replaced with forward slash characters (`/`). This function always returns a string, although it may not be a valid file name. See `validateFileName()`. ### validateFileName(fileName) Returns `null` or a `String` error message depending on the validity of `fileName`. If `fileName` starts with `"/"` or `/[A-Za-z]:\//` or if it contains `".."` path segments or `"\\"`, this function returns an error message appropriate for use like this: ```js var errorMessage = yauzl.validateFileName(fileName); if (errorMessage != null) throw new Error(errorMessage); ``` This function is automatically run for each entry, as long as `decodeStrings` is `true`. See `open()`, `strictFileNames`, and `Event: "entry"` for more information. ### parseExtraFields(extraFieldBuffer) This function is used internally by yauzl to compute [`entry.extraFields`](#extrafields). It is exported in case you want to call it on [`localFileHeader.extraField`](#class-localfileheader). `extraFieldBuffer` is a `Buffer`, such as `localFileHeader.extraField`. Returns an `Array` with each item in the form `{id: id, data: data}`, where `id` is a `Number` and `data` is a `Buffer`. Throws an `Error` if the data encodes an item with a size that exceeds the bounds of the buffer. You may want to surround calls to this function with `try { ... } catch (err) { ... }` to handle the error. ### Class: ZipFile The constructor for the class is not part of the public API. Use `open()`, `fromFd()`, `fromBuffer()`, or `fromRandomAccessReader()` instead. #### Event: "entry" Callback gets `(entry)`, which is an `Entry`. See `open()` and `readEntry()` for when this event is emitted. See also `eachEntry()` for an async iterator alternative to this event. If `decodeStrings` is `true`, entries emitted via this event have already passed file name validation. See `validateFileName()` and `open()` for more information. If `validateEntrySizes` is `true` and this entry's `compressionMethod` is `0` (stored without compression), this entry has already passed entry size validation. See `open()` for more information. #### Event: "end" Emitted after the last `entry` event has been emitted. See `open()` and `readEntry()` for more info on when this event is emitted. See also `eachEntry()` for an async iterator alternative to this event. #### Event: "close" Emitted after the fd is actually closed. This is after calling `close()` (or after the `end` event when `autoClose` is `true`), and after all stream pipelines created from `openReadStream()` have finished reading data from the fd. If this `ZipFile` was acquired from `fromRandomAccessReader()`, the "fd" in the previous paragraph refers to the `RandomAccessReader` implemented by the client. If this `ZipFile` was acquired from `fromBuffer()`, this event is never emitted. #### Event: "error" Emitted in the case of errors with reading the zip file. (Note that other errors can be emitted from the streams created from `openReadStream()` as well.) After this event has been emitted, no further `entry`, `end`, or `error` events will be emitted, but the `close` event may still be emitted. See also `eachEntry()` for an async iterator alternative to this event. #### readEntry() Causes this `ZipFile` to emit an `entry` or `end` event (or an `error` event). This method must only be called when this `ZipFile` was created with the `lazyEntries` option set to `true` (see `open()`), and must not be called if you are using `eachEntry()`. When this `ZipFile` was created with the `lazyEntries` option set to `true`, `entry` and `end` events are only ever emitted in response to this method call. See also `eachEntry()` for an async iterator alternative to this method. The event that is emitted in response to this method will not be emitted until after this method has returned, so it is safe to call this method before attaching event listeners. After calling this method, calling this method again before the response event has been emitted will cause undefined behavior. Calling this method after the `end` event has been emitted will cause undefined behavior. Calling this method after calling `close()` will cause undefined behavior. #### eachEntry() Returns an async iterable/iterator that yields each entry in this `ZipFile`. This allows using `for await (let entry of zipfile.eachEntry()) { ... }` to iterate through the `Entry` objects that would otherwise be emitted via `Event: "entry"`. The object returned from `eachEntry()` implements `next()`, `return()`, and `throw()` satisfying the async iterator API, and implements `[Symbol.asyncIterator]()`, which simply returns `this`, satisfying the async iterable API. `next()` returns a promise which is eventually either rejected with an error, or resolves to one of: * `{value: entry}` with the next `Entry`, analogous to `Event: "entry"`, or * `{done: true}` signaling the end of iteration, analogous to `Event: "end"`. You must abstain from calling `next()` again until the promise returned from the previous call to `next()` has resolved. This is how `for await...of` and `Array.fromAsync()` work. If `autoClose` is `true`, this `ZipFile` is closed at the end of iteration, or when iteration is interrupted by `return()`, which is called implicitly when exiting a `for await...of` loop with `break`, `return`, etc. If you want to still call `openReadStream()` after iteration has ended (such as when using `Array.fromAsync()` to collect entries all ahead of time), set `autoClose` to `false`, and call `close()` manually when you are done with the `ZipFile`. There is no supported way to resume iteration if it is interrupted with `return()`. Using `eachEntry()` is incompatible with older styles of accessing this `ZipFile`. If you use `eachEntry()`: * `lazyEntries` must be `true` (see `open()`). (Some APIs set this automatically for you.) * You must never call `readEntry()` on this `ZipFile`. * It is not recommend to listen for `Event: "entry"` or `Event: "end"`, because that information is fully provided by the async iterator instead. * It is not recommended to listen for `Event: "error"` on this `ZipFile`, but rather handle errors conveyed through the `Promise` API, such as with a `try...catch` block around the `for await...of` expression, or with the `catch()` method on each promise returned by `next()`, etc. * You must not call `eachEntry()` more than once. The iteration state is maintained in the `ZipFile` object itself, not in the iterator, and it is not possible to reset iteration to get the same `Entry` objects more than once. See `examples/promises.js` for an example using this method. #### openReadStream(entry, [options], callback) `entry` must be an `Entry` object from this `ZipFile`. `callback` gets `(err, readStream)`, where `readStream` is a `Readable Stream` that provides the file data for this entry. If this zipfile is already closed (see `close()`), the `callback` will receive an `err`. See also `openReadStreamPromise()` to get `Promise` semantics. `options` may be omitted or `null`, and has the following defaults: ```js { decodeFileData: true, start: 0, // actually the default is null, see below end: entry.compressedSize, // actually the default is null, see below decompress: null, // deprecated decrypt: null, // deprecated } ``` When `decodeFileData` is `true` (or `null` or omitted), yauzl will attempt to decode the file data using a zlib inflate transform when appropriate. Setting `decodeFileData` to `false` will provide the bytes of the entry's contents exactly as-is in the archive. When `compressionMethod` is `0` (stored with no compression) and the entry is not encrypted, `decodeFileData` has no effect. If `canDecodeFileData()` returns `false`, then `decodeFileData` must be set to `false`, or else `callback` will receive an error. It is up to the caller to make sense of any file data with encryption and/or an uncommon compression method. The `start` (inclusive) and `end` (exclusive) options are byte offsets into this entry's file data, and can be used to obtain part of an entry's file data rather than the whole thing. When specifying `start` and/or `end`, it is recommended to unconditionally set `decodeFileData` to `false`. If either `start` and/or `end` are specified and non-`null`, then either `decodeFileData` must be set to `false`, or both `isEncrypted()` must return `false` and `compressionMethod` must be `0`. Specifying `{start: 0, end: entry.compressedSize}` will result in the complete file. For compatibility with versions of yauzl prior to 3.3.x, `start` and `end` can also be used when the deprecated `decompress` and `decrypt` options are used appropriately. This is no longer documented, but an archive of the documentation can be found here: https://github.com/thejoshwolfe/yauzl/blob/c4695215b05c6adffda613b9051a2a85429b33fe/README.md#openreadstreamentry-options-callback It's possible for the `readStream` provided to the `callback` to emit errors for several reasons. For example, if zlib cannot decompress the data, the zlib error will be emitted from the `readStream`. Two more error cases (when `validateEntrySizes` is `true`) are if the decompressed data has too many or too few actual bytes compared to the reported byte count from the entry's `uncompressedSize` field. yauzl notices this false information and emits an error from the `readStream` after some number of bytes have already been piped through the stream. This check allows clients to trust the `uncompressedSize` field in `Entry` objects. Guarding against [zip bomb](http://en.wikipedia.org/wiki/Zip_bomb) attacks can be accomplished by doing some heuristic checks on the size metadata and then watching out for the above errors. Such heuristics are outside the scope of this library, but enforcing the `uncompressedSize` is implemented here as a security feature. It is possible to destroy the `readStream` before it has piped all of its data. To do this, call `readStream.destroy()`. You must `unpipe()` the `readStream` from any destination before calling `readStream.destroy()`. If this zipfile was created using `fromRandomAccessReader()`, the `RandomAccessReader` implementation must provide readable streams that implement a `._destroy()` method according to https://nodejs.org/api/stream.html#writable_destroyerr-callback (see `randomAccessReader._readStreamForRange()`) in order for calls to `readStream.destroy()` to work in this context. #### readLocalFileHeader(entry, [options], callback) This is a low-level function you probably don't need to call. The intended use case is either preparing to call `openReadStreamLowLevel()` or simply examining the content of the local file header out of curiosity or for debugging zip file structure issues. `entry` is an entry obtained from `Event: "entry"`. An `entry` in this library is a file's metadata from a Central Directory Header, and this function gives the corresponding redundant data in a Local File Header. `options` may be omitted or `null`, and has the following defaults: ```js { minimal: false, } ``` If `minimal` is `false` (or omitted or `null`), the callback receives a full [`LocalFileHeader`](#class-localfileheader). If `minimal` is `true`, the callback receives an object with a single property and no prototype `{fileDataStart: fileDataStart}`. For typical zipfile reading usecases, this field is the only one you need, and yauzl internally effectively uses the `{minimal: true}` option as part of `openReadStream()`. The `callback` receives `(err, localFileHeaderOrAnObjectWithJustOneFieldDependingOnTheMinimalOption)`, where the type of the second parameter is described in the above discussion of the `minimal` option. #### openReadStreamLowLevel(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress, uncompressedSize, callback) This is a low-level function available for advanced use cases. You probably want `openReadStream()` instead. See also `openReadStreamLowLevelPromise()` to get `Promise` semantics. The intended use case for this function is calling `readEntry()` and `readLocalFileHeader()` with `{minimal: true}` first, and then opening the read stream at a later time, possibly after closing and reopening the entire zipfile, possibly even in a different process. The parameters are all integers and booleans, which are friendly to serialization. * `fileDataStart` - from `localFileHeader.fileDataStart` * `compressedSize` - from `entry.compressedSize` * `relativeStart` - the resolved value of `options.start` from `openReadStream()`. Must be a non-negative integer, not `null`. Typically `0` to start at the beginning of the data. * `relativeEnd` - the resolved value of `options.end` from `openReadStream()`. Must be a non-negative integer, not `null`. Typically `entry.compressedSize` to include all the data. * `decompress` - boolean indicating whether the data should be piped through a zlib inflate stream. * `uncompressedSize` - from `entry.uncompressedSize`. Only used when `validateEntrySizes` is `true`. If `validateEntrySizes` is `false`, this value is ignored, but must still be present, not omitted, in the arguments; you have to give it some value, even if it's `null`. * `callback` - receives `(err, readStream)`, the same as for `openReadStream()` This low-level function does not read any metadata from the underlying storage before opening the read stream. This is both a performance feature and a safety hazard. None of the integer parameters are bounds checked. None of the validation from `openReadStream()` with respect to compression and encryption is done here either. Only the bounds checks from `validateEntrySizes` are done, because that is part of processing the stream data. #### openReadStreamPromise(entry, [options]) Wraps `openReadStream()` with `Promise` semantics. The returned promise is rejected if the `callback` for `openReadStream()` receives an `err`, otherwise the promise is resolved with the `readStream`. `entry` and `options` are passed directly to `openReadStream()`. #### readLocalFileHeaderPromise(entry, [options]) Wraps `readLocalFileHeader()` with `Promise` semantics. The returned promise is rejected if the `callback` for `readLocalFileHeader()` receives an `err`, otherwise the promise is resolved with the `readStream`. `entry` and `options` are passed directly to `readLocalFileHeader()`. #### openReadStreamLowLevelPromise(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress, uncompressedSize) Wraps `openReadStreamLowLevel()` with `Promise` semantics. The returned promise is rejected if the `callback` for `openReadStreamLowLevel()` receives an `err`, otherwise the promise is resolved with the `readStream`. All arguments, `fileDataStart`, `compressedSize`, `relativeStart`, `relativeEnd`, `decompress`, and `uncompressedSize`, are passed directly to `openReadStreamLowLevel()`. #### close() Causes all future calls to `openReadStream()` to fail, and closes the fd, if any, after all streams created by `openReadStream()` have emitted their `end` events. If the `autoClose` option is set to `true` (see `open()`), this function will be called automatically effectively in response to this object's `end` event. If the `lazyEntries` option is set to `false` (see `open()`) and this object's `end` event has not been emitted yet, this function causes undefined behavior. If the `lazyEntries` option is set to `true`, you can call this function instead of calling `readEntry()` to abort reading the entries of a zipfile. It is safe to call this function multiple times; after the first call, successive calls have no effect. This includes situations where the `autoClose` option effectively calls this function for you. If `close()` is never called, then the zipfile is "kept open". For zipfiles created with `fromFd()`, this will leave the `fd` open, which may be desirable. For zipfiles created with `open()`, this will leave the underlying `fd` open, thereby "leaking" it, which is probably undesirable. For zipfiles created with `fromRandomAccessReader()`, the reader's `close()` method will never be called. For zipfiles created with `fromBuffer()`, the `close()` function has no effect on resource usage. Regardless of how this `ZipFile` was created, there are no resources other than those listed above that require cleanup from this function. This means it may be desirable to never call `close()` in some usecases. #### isOpen `Boolean`. `true` until `close()` is called; then it's `false`. #### entryCount `Number`. Total number of central directory records. #### comment `String`. Always decoded with `CP437` per the spec. If `decodeStrings` is `false` (see `open()`), this field is the undecoded `Buffer` instead of a decoded `String`. ### Class: Entry Objects of this class represent Central Directory Records. Refer to the zipfile specification for more details about these fields. These fields are of type `Number`: * `versionMadeBy` * `versionNeededToExtract` * `generalPurposeBitFlag` * `compressionMethod` * `lastModFileTime` (MS-DOS format, see [`getLastModDate()`](#getlastmoddateoptions)) * `lastModFileDate` (MS-DOS format, see [`getLastModDate()`](#getlastmoddateoptions)) * `crc32` * `compressedSize` * `uncompressedSize` * `fileNameLength` (in bytes) * `extraFieldLength` (in bytes) * `fileCommentLength` (in bytes) * `internalFileAttributes` * `externalFileAttributes` * `relativeOffsetOfLocalHeader` These fields are of type `Buffer`, and represent variable-length bytes before being processed: * `fileNameRaw` * `extraFieldRaw` * `fileCommentRaw` There are additional fields described below: `fileName`, `extraFields`, `fileComment`. These are the processed versions of the `*Raw` fields listed above. See their own sections below. (Note the inconsistency in pluralization of "field" vs "fields" in `extraField`, `extraFields`, and `extraFieldRaw`. Sorry about that.) The `new Entry()` constructor is available for clients to call, but it's usually not useful. The constructor takes no parameters and does nothing; no fields will exist. #### fileName `String`. Following the spec, the bytes for the file name are decoded with `UTF-8` if `generalPurposeBitFlag & 0x800`, otherwise with `CP437`. Alternatively, this field may be populated from the Info-ZIP Unicode Path Extra Field (see `extraFields`). This field is automatically validated by `validateFileName()` before yauzl emits an "entry" event. If this field would contain unsafe characters, yauzl emits an error instead of an entry. If `decodeStrings` is `false` (see `open()`), this field is the undecoded `Buffer` instead of a decoded `String`. Therefore, `generalPurposeBitFlag` and any Info-ZIP Unicode Path Extra Field are ignored. Furthermore, no automatic file name validation is performed for this file name. #### extraFields `Array` with each item in the form `{id: id, data: data}`, where `id` is a `Number` and `data` is a `Buffer`. This library looks for and reads the ZIP64 Extended Information Extra Field (0x0001) in order to support ZIP64 format zip files. This library also looks for and reads the Info-ZIP Unicode Path Extra Field (0x7075) in order to support some zipfiles that use it instead of General Purpose Bit 11 to convey `UTF-8` file names. When the field is identified and verified to be reliable (see the zipfile spec), the file name in this field is stored in the `fileName` property, and the file name in the central directory record for this entry is ignored. Note that when `decodeStrings` is false, all Info-ZIP Unicode Path Extra Fields are ignored. See also [`getLastModDate()`](#getlastmoddateoptions) for additional extra fields that are recognized by this library. #### fileComment `String` decoded with the charset indicated by `generalPurposeBitFlag & 0x800` as with the `fileName`. (The Info-ZIP Unicode Path Extra Field has no effect on the charset used for this field.) If `decodeStrings` is `false` (see `open()`), this field is the undecoded `Buffer` instead of a decoded `String`. Prior to yauzl version 2.7.0, this field was erroneously documented as `comment` instead of `fileComment`. For compatibility with any code that uses the field name `comment`, yauzl creates an alias field named `comment` which is identical to `fileComment`. #### getLastModDate([options]) Returns the modification time of the file as a JavaScript `Date` object. The timezone situation is a mess due to both ZIP issues and JavaScript issues; read on to learn more. Due to the zip file specification having lackluster support for specifying timestamps natively, there are several third-party extensions that add better support in the `extraFields`. yauzl supports these encodings: 1. Info-ZIP "universal timestamp" extended field (`0x5455` aka `"UT"`): signed 32-bit seconds since `1970-01-01 00:00:00Z`, which supports the years 1901-2038 (partially inclusive) with 1-second precision. The value is timezone agnostic, i.e. always UTC. 2. NTFS extended field (`0x000a`): 64-bit signed 100-nanoseconds since `1601-01-01 00:00:00Z`, which supports the approximate years 20,000BCE-20,000CE with precision rounded to 1-millisecond (due to the JavaScript `Date` type). The value is timezone agnostic, i.e. always UTC. 3. DOS `lastModFileDate` and `lastModFileTime`: supports the years 1980-2108 (inclusive) with 2-second precision. Timezone is interpreted either as the local timezone or UTC depending on the `timezone` option documented below. If both the Info-ZIP "universal timestamp" and NTFS extended fields are found, yauzl uses one of them, but which one is unspecified. If neither are found, yauzl falls back to the built-in DOS `lastModFileDate` and `lastModFileTime`. Every possible bit pattern of every encoding can be represented by a JavaScript `Date` object, meaning this function cannot fail (barring parameter validation), and will never return an `Invalid Date` object. `options` may be omitted or `null`, and has the following defaults: ```js { timezone: "local", // or "UTC" forceDosFormat: false, } ``` Set `forceDosFormat` to `true` (and do not set `timezone`) to enable pre-yauzl 3.2.0 behavior where the Info-ZIP "universal timestamp" and NTFS extended fields are ignored. The `timezone` option is only used in the DOS fallback. If `timezone` is `"local"` (or omitted or `null`), the `lastModFileDate` and `lastModFileTime` are interpreted in the system's current timezone (using `new Date(year, ...)`). If `timezone` is `"UTC"`, the interpretation is in UTC+00:00 (using `new Date(Date.UTC(year, ...))`). The JavaScript `Date` object, has several inherent limitations surrounding timezones. There is an ECMAScript proposal to add better timezone support to JavaScript called the `Temporal` API. Last I checked, it was at stage 4. https://github.com/tc39/proposal-temporal Once that new API is available and stable, better timezone handling should be possible here somehow. If you notice that the new API has become widely available, please open a feature request against this library to add support for it. #### canDecodeFileData() Returns `true` if and only if the metadata for this entry specifies an encoding that yauzl can automatically decode as part of `openReadStream()`. This considers compression method and encryption. Only compression methods `0` (stored with no compression) and `8` (deflated) are supported, and neither traditional encryption nor strong encryption is supported. See also `openReadStream()`. #### isEncrypted() Note that "Strong Encryption" is not supported, and will result in an `"error"` event emitted from the `ZipFile`. This method is effectively implemented as `return (this.generalPurposeBitFlag & 0x1) !== 0`. yauzl provides no functionality to decrypt file data. #### isCompressed() *DEPRECATED*: use `canDecodeFileData()` instead, and/or manually check `compressionMethod`. This method is effectively implemented as `return this.compressionMethod === 8`, which misleadingly returns `false` for entries that are compressed using a compression method other than `8`. This implementation is maintained for backward compatibility with yauzl versions prior to 3.3.x. ### Class: LocalFileHeader This is a trivial class that has no methods and only the following properties. The constructor is available to call, but it doesn't do anything. See `readLocalFileHeader()`. See the zipfile spec for what these fields mean. * `fileDataStart` - `Number`: inferred from `fileNameLength`, `extraFieldLength`, and this struct's position in the zipfile. * `versionNeededToExtract` - `Number` * `generalPurposeBitFlag` - `Number` * `compressionMethod` - `Number` * `lastModFileTime` - `Number` * `lastModFileDate` - `Number` * `crc32` - `Number` * `compressedSize` - `Number` * `uncompressedSize` - `Number` * `fileNameLength` - `Number` * `extraFieldLength` - `Number` * `fileName` - `Buffer` * `extraField` - `Buffer` Note that unlike `Class: Entry`, the `fileName` and `extraField` are completely unprocessed. This notably lacks Unicode and ZIP64 handling as well as any kind of safety validation on the file name. See also [`parseExtraFields()`](#parseextrafields-extrafieldbuffer). Also note that if your object is missing some of these fields, make sure to read the docs on the `minimal` option in `readLocalFileHeader()`. ### Class: RandomAccessReader This class is meant to be subclassed by clients and instantiated for the `fromRandomAccessReader()` function. An example implementation can be found in `test/test.js`. #### randomAccessReader._readStreamForRange(start, end) Subclasses *must* implement this method. `start` and `end` are Numbers and indicate byte offsets from the start of the file. `end` is exclusive, so `_readStreamForRange(0x1000, 0x2000)` would indicate to read `0x1000` bytes. `end - start` will always be at least `1`. This method should return a readable stream which will be `pipe()`ed into another stream. It is expected that the readable stream will provide data in several chunks if necessary. If the readable stream provides too many or too few bytes, an error will be emitted. (Note that `validateEntrySizes` has no effect on this check, because this is a low-level API that should behave correctly regardless of the contents of the file.) Any errors emitted on the readable stream will be handled and re-emitted on the client-visible stream (returned from `zipfile.openReadStream()`) or provided as the `err` argument to the appropriate callback (for example, for `fromRandomAccessReader()`). If you call `readStream.destroy()` on streams you get from `openReadStream()`, the returned stream *must* implement a method `._destroy()` according to https://nodejs.org/api/stream.html#writable_destroyerr-callback . If you never call `readStream.destroy()`, then streams returned from this method do not need to implement a method `._destroy()`. `._destroy()` should abort any streaming that is in progress and clean up any associated resources. `._destroy()` will only be called after the stream has been `unpipe()`d from its destination. Note that the stream returned from this method might not be the same object that is provided by `openReadStream()`. The stream returned from this method might be `pipe()`d through one or more filter streams (for example, a zlib inflate stream). #### randomAccessReader.read(buffer, offset, length, position, callback) Subclasses may implement this method. The default implementation uses `createReadStream()` to fill the `buffer`. This method should behave like `fs.read()`. #### randomAccessReader.close(callback) Subclasses may implement this method. The default implementation is effectively `setImmediate(callback);`. `callback` takes parameters `(err)`. This method is called once the all streams returned from `_readStreamForRange()` have ended, and no more `_readStreamForRange()` or `read()` requests will be issued to this object. ## How to Avoid Crashing When a malformed zipfile is encountered, the default behavior is to crash (throw an exception). If you want to handle errors more gracefully than this, be sure to do the following: * When using an API with a `callback` parameter, check the `err` parameter. * When using an API that returns a `Promise`, check for promise rejection. * When accessing entries via `Event: "entry"` and `Event: "end"`, attach a listener for `Event: "error"` on the `ZipFile`. * When accessing entires via `eachEntry()`, check for promise rejection on each returned promise. (When using `await` or `for await...of`, rejections will be thrown by those language constructs and must be caught with `try...catch`.) * Read streams for entries (such as from `openReadStream()`) can produce errors. Either attach a listen for `Event: "error"` on the read stream, or handle the error some other way. ## Limitations The automated tests for this project run on node versions 12 and up. Older versions of node are not supported. ### Files corrupted by the Mac Archive Utility are not my problem For a lengthy discussion, see [issue #69](https://github.com/thejoshwolfe/yauzl/issues/69). In summary, the Mac Archive Utility is buggy when creating large zip files, and this library does not make any effort to work around the bugs. This library will attempt to interpret the zip file data at face value, which may result in errors, or even silently incomplete data. If this bothers you, that's good! Please complain to Apple. :) I have accepted that this library will simply not support that nonsense. ### No Streaming Unzip API Due to the design of the .zip file format, it's impossible to interpret a .zip file from start to finish (such as from a readable stream) without sacrificing correctness. The Central Directory, which is the authority on the contents of the .zip file, is at the end of a .zip file, not the beginning. A streaming API would need to either buffer the entire .zip file to get to the Central Directory before interpreting anything (defeating the purpose of a streaming interface), or rely on the Local File Headers which are interspersed through the .zip file. However, the Local File Headers are explicitly denounced in the spec as being unreliable copies of the Central Directory, so trusting them would be a violation of the spec. Any library that offers a streaming unzip API must make one of the above two compromises, which makes the library either dishonest or nonconformant (usually the latter). This library insists on correctness and adherence to the spec, and so does not offer a streaming API. Here is a way to create a spec-conformant .zip file using the `zip` command line program (Info-ZIP) available in most unix-like environments, that is (nearly) impossible to parse correctly with a streaming parser: ``` $ echo -ne '\x50\x4b\x07\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' > file.txt $ zip -q0 - file.txt | cat > out.zip ``` This .zip file contains a single file entry that uses General Purpose Bit 3, which means the Local File Header doesn't know the size of the file. Any streaming parser that encounters this situation will either immediately fail, or attempt to search for the Data Descriptor after the file's contents. The file's contents is a sequence of 16-bytes crafted to exactly mimic a valid Data Descriptor for an empty file, which will fool any parser that gets this far into thinking that the file is empty rather than containing 16-bytes. What follows the file's real contents is the file's real Data Descriptor, which will likely cause some kind of signature mismatch error for a streaming parser (if one hasn't occurred already). By using General Purpose Bit 3 (and compression method 0), it's possible to create arbitrarily ambiguous .zip files that distract parsers with file contents that contain apparently valid .zip file metadata. ### Limited ZIP64 Support For ZIP64, only zip files smaller than `8PiB` are supported, not the full `16EiB` range that a 64-bit integer should be able to index. This is due to the JavaScript Number type being an IEEE 754 double precision float. The Node.js `fs` module probably has this same limitation. ### ZIP64 Extensible Data Sector Is Ignored The spec does not allow zip file creators to put arbitrary data here, but rather reserves its use for PKWARE and mentions something about Z390. This doesn't seem useful to expose in this library, so it is ignored. ### No Multi-Disk Archive Support This library does not support multi-disk zip files. The multi-disk fields in the zipfile spec were intended for a zip file to span multiple floppy disks, which probably never happens now. If the "number of this disk" field in the End of Central Directory Record is not `0`, the `open()`, `fromFd()`, `fromBuffer()`, or `fromRandomAccessReader()` `callback` will receive an `err`. By extension the following zip file fields are ignored by this library and not provided to clients: * Disk where central directory starts * Number of central directory records on this disk * Disk number where file starts ### Limited Encryption Handling You can detect when a file entry is encrypted with "Traditional Encryption" via `generalPurposeBitFlag`, but yauzl will not help you decrypt it. See the `openReadStream()` option `decodeFileData`. If a zip file contains file entries encrypted with "Strong Encryption", yauzl emits an error. If the central directory is encrypted or compressed, yauzl emits an error. ### Local File Headers Are Ignored Many unzip libraries mistakenly read the Local File Header data in zip files. This data is officially defined to be redundant with the Central Directory information, and is not to be trusted. Aside from checking the signature, yauzl ignores the content of the Local File Header. ### No CRC-32 Checking This library provides the `crc32` field of `Entry` objects read from the Central Directory. However, this field is not used for anything in this library. ### versionNeededToExtract Is Ignored The field `versionNeededToExtract` is ignored, because this library doesn't support the complete zip file spec at any version, ### No Support For Obscure Compression Methods Regarding the `compressionMethod` field of `Entry` objects, only method `0` (stored with no compression) and method `8` (deflated) are supported. Any of the other 15 official methods will cause the `openReadStream()` `callback` to receive an `err`. ### Data Descriptors Are Ignored There may or may not be Data Descriptor sections in a zip file. This library provides no support for finding or interpreting them. ### Archive Extra Data Record Is Ignored There may or may not be an Archive Extra Data Record section in a zip file. This library provides no support for finding or interpreting it. ### No Language Encoding Flag Support Zip files officially support charset encodings other than CP437 and UTF-8, but the zip file spec does not specify how it works. This library makes no attempt to interpret the Language Encoding Flag. ### How Ambiguities Are Handled The zip file specification has several ambiguities inherent in its design. Yikes! * The `.ZIP file comment` must not contain the `end of central dir signature` bytes `50 4b 05 06`. This corresponds to the text `"PK☺☻"` in CP437. While this is allowed by the specification, yauzl will hopefully reject this situation with an "Invalid comment length" error. However, in some situations unpredictable incorrect behavior will ensue, which will probably manifest in either an invalid signature error or some kind of bounds check error, such as "Unexpected EOF". * In non-ZIP64 files, the last central directory header must not have the bytes `50 4b 06 07` (`"PK♠•"` in CP437) exactly 20 bytes from its end, which might be in the `file name`, the `extra field`, or the `file comment`. The presence of these bytes indicates that this is a ZIP64 file. ## Change History * 3.4.0 * Add wrapper functions that give Promise semantics: `openPromise()`, `fromFdPromise()`, `fromBufferPromise()`, `fromRandomAccessReaderPromise()`, `openReadStreamPromise()`, `readLocalFileHeaderPromise()`, `openReadStreamLowLevelPromise()`. [pull #171](https://github.com/thejoshwolfe/yauzl/pull/171) * Add `eachEntry()`, which gives async iterator semantics as an alternative to `readEntry()`, `Event: "entry"`, `Event: "end"`, and `Event: "error"`. * Added more modern examples to `README.md` and `examples/` using `await` on the new APIs. * Added a `CONTRIBUTING.md`. * 3.3.2 * Vendor and simplify `buffer-crc` dependency and prefer `zlib.crc32()` when available. [issue #172](https://github.com/thejoshwolfe/yauzl/issues/172) [pull #173](https://github.com/thejoshwolfe/yauzl/pull/173) * Fixed typo in error handling for obscure IO errors. Raised in [issue #174](https://github.com/thejoshwolfe/yauzl/issues/174). * 3.3.1 * Fixed bugs related to interrupting streams with `destroy()` and with async iteration on read streams. [issue #169](https://github.com/thejoshwolfe/yauzl/issues/169) [pull #170](https://github.com/thejoshwolfe/yauzl/pull/170) * 3.3.0 * Added `entry.canDecodeFileData()` and option `decodeFileData` for `entry.openReadStream()`, and marked as deprecated `isCompressed()` and options `decompress` and `decrypt`. [issue #80](https://github.com/thejoshwolfe/yauzl/issues/80) [pull #81](https://github.com/thejoshwolfe/yauzl/pull/81) [pull #82](https://github.com/thejoshwolfe/yauzl/pull/82) [issue #166](https://github.com/thejoshwolfe/yauzl/issues/166) * 3.2.1 * Fix crash when reading certain corrupted NTFS timestamp extra fields. Thanks to CodeAnt AI Code Reviewer ( https://www.codeant.ai/ai-code-review ) for finding the bug. * 3.2.0 * Added support for reading third-party extensions for timestamps: Info-ZIP "universal timestamp" extra field and NTFS extra field. [pull #160](https://github.com/thejoshwolfe/yauzl/pull/160) * `entry.getLastModDate()` takes options `forceDosFormat` to revert the above change, and `timezone` to allow UTC interpretation of DOS timestamps. * Documented `dosDateTimeToDate()` as now deprecated. * 3.1.3 * Fixed a crash when using `fromBuffer()` to read corrupt zip files that specify out of bounds file offsets. [issue #156](https://github.com/thejoshwolfe/yauzl/pull/156) * Enahnced the test suite to run the error tests through `fromBuffer()` and `fromRandomAccessReader()` in addition to `open()`, which would have caught the above. * 3.1.2 * Fixed handling non-64 bit entries (similar to the version 3.1.1 fix) that actually have exactly 0xffffffff values in the fields. This fixes erroneous "expected zip64 extended information extra field" errors. [issue #109](https://github.com/thejoshwolfe/yauzl/pull/109) * 3.1.1 * Fixed handling non-64 bit files that actually have exactly 0xffff or 0xffffffff values in End of Central Directory Record. This fixes erroneous "invalid zip64 end of central directory locator signature" errors. [issue #108](https://github.com/thejoshwolfe/yauzl/pull/108) * Fixed handling of 64-bit zip files that put 0xffff or 0xffffffff in every field overridden in the Zip64 end of central directory record even if the value would have fit without overflow. In particular, this fixes an incorrect "multi-disk zip files are not supported" error. [pull #118](https://github.com/thejoshwolfe/yauzl/pull/118) * 3.1.0 * Added `readLocalFileHeader()` and `Class: LocalFileHeader`. * Added `openReadStreamLowLevel()`. * Added `getFileNameLowLevel()` and `parseExtraFields()`. Added fields to `Class: Entry`: `fileNameRaw`, `extraFieldRaw`, `fileCommentRaw`. * Added `examples/compareCentralAndLocalHeaders.js` that demonstrate many of these low level APIs. * Noted dropped support of node versions before 12 in the `"engines"` field of `package.json`. * Fixed a crash when calling `openReadStream()` with an explicitly `null` options parameter (as opposed to omitted). * 3.0.0 * BREAKING CHANGE: implementations of [RandomAccessReader](#class-randomaccessreader) that implement a `destroy` method must instead implement `_destroy` in accordance with the node standard https://nodejs.org/api/stream.html#writable_destroyerr-callback (note the error and callback parameters). If you continue to override `destory` instead, some error handling may be subtly broken. Additionally, this is required for async iterators to work correctly in some versions of node. [issue #110](https://github.com/thejoshwolfe/yauzl/issues/110) * BREAKING CHANGE: Drop support for node versions older than 12. * Maintenance: Fix buffer deprecation warning by bundling `fd-slicer` with a 1-line change, rather than depending on it. [issue #114](https://github.com/thejoshwolfe/yauzl/issues/114) * Maintenance: Upgrade `bl` dependency; add `package-lock.json`; drop deprecated istanbul dependency. This resolves all security warnings for this project. [pull #125](https://github.com/thejoshwolfe/yauzl/pull/125) * Maintenance: Replace broken Travis CI with GitHub Actions. [pull #148](https://github.com/thejoshwolfe/yauzl/pull/148) * Maintenance: Fixed a long-standing issue in the test suite where a premature exit would incorrectly signal success. * Officially gave up on supporting Mac Archive Utility corruption in order to rescue my motivation for this project. [issue #69](https://github.com/thejoshwolfe/yauzl/issues/69) * 2.10.0 * Added support for non-conformant zipfiles created by Microsoft, and added option `strictFileNames` to disable the workaround. [issue #66](https://github.com/thejoshwolfe/yauzl/issues/66), [issue #88](https://github.com/thejoshwolfe/yauzl/issues/88) * 2.9.2 * Removed `tools/hexdump-zip.js` and `tools/hex2bin.js`. Those tools are now located here: [thejoshwolfe/hexdump-zip](https://github.com/thejoshwolfe/hexdump-zip) and [thejoshwolfe/hex2bin](https://github.com/thejoshwolfe/hex2bin) * Worked around performance problem with zlib when using `fromBuffer()` and `readStream.destroy()` for large compressed files. [issue #87](https://github.com/thejoshwolfe/yauzl/issues/87) * 2.9.1 * Removed `console.log()` accidentally introduced in 2.9.0. [issue #64](https://github.com/thejoshwolfe/yauzl/issues/64) * 2.9.0 * Throw an exception if `readEntry()` is called without `lazyEntries:true`. Previously this caused undefined behavior. [issue #63](https://github.com/thejoshwolfe/yauzl/issues/63) * 2.8.0 * Added option `validateEntrySizes`. [issue #53](https://github.com/thejoshwolfe/yauzl/issues/53) * Added `examples/promises.js` * Added ability to read raw file data via `decompress` and `decrypt` options. [issue #11](https://github.com/thejoshwolfe/yauzl/issues/11), [issue #38](https://github.com/thejoshwolfe/yauzl/issues/38), [pull #39](https://github.com/thejoshwolfe/yauzl/pull/39) * Added `start` and `end` options to `openReadStream()`. [issue #38](https://github.com/thejoshwolfe/yauzl/issues/38) * 2.7.0 * Added option `decodeStrings`. [issue #42](https://github.com/thejoshwolfe/yauzl/issues/42) * Fixed documentation for `entry.fileComment` and added compatibility alias. [issue #47](https://github.com/thejoshwolfe/yauzl/issues/47) * 2.6.0 * Support Info-ZIP Unicode Path Extra Field, used by WinRAR for Chinese file names. [issue #33](https://github.com/thejoshwolfe/yauzl/issues/33) * 2.5.0 * Ignore malformed Extra Field that is common in Android .apk files. [issue #31](https://github.com/thejoshwolfe/yauzl/issues/31) * 2.4.3 * Fix crash when parsing malformed Extra Field buffers. [issue #31](https://github.com/thejoshwolfe/yauzl/issues/31) * 2.4.2 * Remove .npmignore and .travis.yml from npm package. * 2.4.1 * Fix error handling. * 2.4.0 * Add ZIP64 support. [issue #6](https://github.com/thejoshwolfe/yauzl/issues/6) * Add `lazyEntries` option. [issue #22](https://github.com/thejoshwolfe/yauzl/issues/22) * Add `readStream.destroy()` method. [issue #26](https://github.com/thejoshwolfe/yauzl/issues/26) * Add `fromRandomAccessReader()`. [issue #14](https://github.com/thejoshwolfe/yauzl/issues/14) * Add `examples/unzip.js`. * 2.3.1 * Documentation updates. * 2.3.0 * Check that `uncompressedSize` is correct, or else emit an error. [issue #13](https://github.com/thejoshwolfe/yauzl/issues/13) * 2.2.1 * Update dependencies. * 2.2.0 * Update dependencies. * 2.1.0 * Remove dependency on `iconv`. * 2.0.3 * Fix crash when trying to read a 0-byte file. * 2.0.2 * Fix event behavior after errors. * 2.0.1 * Fix bug with using `iconv`. * 2.0.0 * Initial release. ## Development One of the trickiest things in development is crafting test cases located in `test/{success,failure}/`. These are zip files that have been specifically generated or design to test certain conditions in this library. I recommend using [hexdump-zip](https://github.com/thejoshwolfe/hexdump-zip) to examine the structure of a zipfile. For making new error cases, I typically start by copying `test/success/linux-info-zip.zip`, and then editing a few bytes with a hex editor. yauzl-3.4.0/crc32.js000066400000000000000000000065521521126516100141440ustar00rootroot00000000000000// Adapted from https://github.com/brianloveswords/buffer-crc32/blob/v0.2.13/index.js const CRC_TABLE = new Int32Array([ 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d, ]); function crc32(buf) { let crc = -1; for (let x of buf) { crc = CRC_TABLE[(crc ^ x) & 0xff] ^ (crc >>> 8); } return (crc ^ -1) >>> 0; } module.exports = crc32; yauzl-3.4.0/examples/000077500000000000000000000000001521126516100145005ustar00rootroot00000000000000yauzl-3.4.0/examples/compareCentralAndLocalHeaders.js000066400000000000000000000111521521126516100226670ustar00rootroot00000000000000 var yauzl = require("../"); // replace with: var yauzl = require("yauzl"); function usage() { console.log( "usage: node compareCentralAndLocalHeaders.js path/to/file.zip\n" + "\n" + "Shows a table comparing the central directory metadata and local\n" + "file headers for each item in a zipfile.\n" + ""); process.exit(1); } var zipfilePath = null; var detailedExtraFieldBreakdown = true; process.argv.slice(2).forEach(function(arg) { if (/^-/.test(arg)) usage(); if (zipfilePath != null) usage(); zipfilePath = arg; }); if (zipfilePath == null) usage(); yauzl.open(zipfilePath, {lazyEntries: true, decodeStrings: false}, function(err, zipfile) { if (err) throw err; zipfile.on("error", function(err) { throw err; }); zipfile.readEntry(); zipfile.on("entry", function(entry) { zipfile.readLocalFileHeader(entry, function(err, localFileHeader) { if (err) throw err; compare(entry, localFileHeader); zipfile.readEntry(); }); }); }) function compare(entry, localFileHeader) { console.log(yauzl.getFileNameLowLevel(entry.generalPurposeBitFlag, entry.fileNameRaw, entry.extraFields, false)); // Compare integers var integerFields = [ "versionMadeBy", "versionNeededToExtract", "generalPurposeBitFlag", "compressionMethod", "lastModFileTime", "lastModFileDate", "crc32", "compressedSize", "uncompressedSize", "fileNameLength", "extraFieldLength", "fileCommentLength", "internalFileAttributes", "externalFileAttributes", "relativeOffsetOfLocalHeader", ]; function formatNumber(numberOrNull) { if (numberOrNull == null) return "-"; return "0x" + numberOrNull.toString(16); } var rows = [["field", "central", "local", "diff"]]; rows.push(...integerFields.map(function(name) { var a = entry[name]; var b = localFileHeader[name]; var diff = a == null || b == null ? "" : a === b ? "" : "x"; return [name, formatNumber(a), formatNumber(b), diff] })); var columnWidths = [0, 1, 2, 3].map(function(i) { return Math.max(...rows.map(row => row[i].length)); }); var formatFunctions = ["padEnd", "padStart", "padStart", "padEnd"]; console.log("┌" + columnWidths.map(w => "─".repeat(w)).join("┬") + "┐"); for (var i = 0; i < rows.length; i++) { console.log("│" + rows[i].map((x, j) => x[formatFunctions[j]](columnWidths[j])).join("│") + "│"); if (i === 0) { console.log("├" + columnWidths.map(w => "─".repeat(w)).join("┼") + "┤"); } } console.log("└" + columnWidths.map(w => "─".repeat(w)).join("┴") + "┘"); // Compare variable length data. console.log("central.fileName:", entry.fileNameRaw.toString("hex")); if (entry.fileNameRaw.equals(localFileHeader.fileName)) { console.log("(local matches)"); } else { console.log(" local.fileName:", localFileHeader.fileName.toString("hex")); } console.log("central.extraField:", entry.extraFieldRaw.toString("hex")); if (entry.extraFieldRaw.equals(localFileHeader.extraField)) { console.log("(local matches)"); } else { console.log(" local.extraField:", localFileHeader.extraField.toString("hex")); } if (detailedExtraFieldBreakdown) { var centralExtraFieldMap = extraFieldsToMap(entry.extraFields); var localExtraFieldMap = extraFieldsToMap(yauzl.parseExtraFields(localFileHeader.extraField)); for (var key in centralExtraFieldMap) { var centralData = centralExtraFieldMap[key]; var localData = localExtraFieldMap[key]; delete localExtraFieldMap[key]; // to isolate unhandled keys. console.log(" [" + key + "]central:", centralData.toString("hex")); if (localData != null && centralData.equals(localData)) { console.log(" [" + key + "](local matches)"); } else if (localData != null) { console.log(" [" + key + "] local:", localData.toString("hex")); } else { console.log(" [" + key + "] local: "); } } // Any keys left here don't match anything. for (var key in localExtraFieldMap) { var localData = localExtraFieldMap[key]; console.log(" [" + key + "]central: "); console.log(" [" + key + "] local:", localData.toString("hex")); } } console.log("central.comment:", entry.fileCommentRaw.toString("hex")); console.log(""); } function extraFieldsToMap(extraFields) { var map = {}; extraFields.forEach(({id, data}) => { var key = "0x" + id.toString(16).padStart(4, "0"); var baseKey = key; var i = 1; while (key in map) { key = baseKey + "." + i; i++; } map[key] = data; }); return map; } yauzl-3.4.0/examples/dump.js000066400000000000000000000013631521126516100160060ustar00rootroot00000000000000 var yauzl = require("../"); // replace with: var yauzl = require("yauzl"); var paths = []; var dumpContents = true; process.argv.slice(2).forEach(function(arg) { if (arg === "--no-contents") { dumpContents = false; } else { paths.push(arg); } }); paths.forEach(function(path) { yauzl.open(path, function(err, zipfile) { if (err) throw err; zipfile.on("error", function(err) { throw err; }); zipfile.on("entry", function(entry) { console.log(entry); console.log(entry.getLastModDate()); if (!dumpContents || /\/$/.exec(entry)) return; zipfile.openReadStream(entry, function(err, readStream) { if (err) throw err; readStream.pipe(process.stdout); }); }); }); }); yauzl-3.4.0/examples/promises.js000066400000000000000000000035351521126516100167050ustar00rootroot00000000000000const yauzl = require("../"); // replace with: const yauzl = require("yauzl"); // Parse CLI args. const paths = []; let dumpContents = true; let shouldReadStream = true; process.argv.slice(2).forEach(function(arg) { if (arg === "--no-contents") { dumpContents = false; } else if (arg === "--no-readStream") { shouldReadStream = false; } else { paths.push(arg); } }); // Read each arg .zip and dump its contents to stdout. (async () => { for (let path of paths) { try { const zipfile = await yauzl.openPromise(path); for await (let entry of zipfile.eachEntry()) { console.log(entry); if (!shouldReadStream || entry.fileName.endsWith("/")) continue; const readStream = await zipfile.openReadStreamPromise(entry); // You should just use readStream.pipe(process.stdout) if you don't care about individual chunks. // This example demonstrates detailed involvement in the piping process. let chunksSeen = 0; for await (let chunk of readStream) { console.log("seeing chunk:", chunksSeen); chunksSeen++; if (chunksSeen === 10) { console.log("interrupting the read stream"); readStream.destroy(); break; } if (dumpContents) { await writeToStream(process.stdout, chunk); } } console.log(`readStream completed in ${chunksSeen} chunks`); } } catch (err) { // yauzl errors get thrown by `await` expressions and end up here. throw err; } } })(); function writeToStream(stream, chunk) { // As of 2023, you have to write this function in your own code. // https://github.com/nodejs/node/issues/49658 return new Promise(resolve => { if (!stream.write(chunk)) { stream.once('drain', resolve); } else { resolve(); } }); } yauzl-3.4.0/examples/unzip.js000066400000000000000000000154631521126516100162140ustar00rootroot00000000000000 var yauzl = require("../"); // replace with: var yauzl = require("yauzl"); var path = require("path"); var fs = require("fs"); var util = require("util"); var Transform = require("stream").Transform; var zipFilePath; var offsetArg; var lenArg; var endArg; var args = process.argv.slice(2); for (var i = 0; i < args.length; i++) { var arg = args[i]; if (arg === "--offset") { i += 1; offsetArg = parseInt(args[i]); if (isNaN(offsetArg)) throw new Error("--offset argument not parsable as an int"); } else if (arg === "--len") { i += 1; lenArg = parseInt(args[i]); if (isNaN(lenArg)) throw new Error("--len argument not parsable as an int"); } else if (arg === "--end") { i += 1; endArg = parseInt(args[i]); if (isNaN(endArg)) throw new Error("--end argument not parsable as an int"); } else if (["-h", "--help"].indexOf(arg) !== -1) { // print help zipFilePath = null; break; } else if (/^--/.test(arg)) { throw new Error("unrecognized option: " + arg); } else { if (zipFilePath != null) throw new Error("too many arguments"); zipFilePath = arg; } } if (zipFilePath == null || /^-/.test(zipFilePath) || (lenArg != null && endArg != null)) { console.log( "usage: node unzip.js [options] path/to/file.zip\n" + "\n" + "unzips the specified zip file into the current directory\n" + "\n" + "options:\n" + " --offset START\n" + " --len LEN\n" + " --end END\n" + " interprets the middle of the specified file as a zipfile.\n" + " starting START number of bytes in from the beginning (default 0).\n" + " end with length of LEN (default is all the way to the end of the file).\n" + " or end at byte offset END (exclusive) (default is the end of the file).\n" + " end can be negative to count backwards from the end of the file\n" + " (example, `--end -1` excludes the last byte of the file).\n" + ""); process.exit(1); } function mkdirp(dir, cb) { if (dir === ".") return cb(); fs.stat(dir, function(err) { if (err == null) return cb(); // already exists var parent = path.dirname(dir); mkdirp(parent, function() { process.stdout.write(dir.replace(/\/$/, "") + "/\n"); fs.mkdir(dir, cb); }); }); } if (offsetArg != null || lenArg != null || endArg != null) { openMiddleOfFile(zipFilePath, {lazyEntries: true}, offsetArg, lenArg, endArg, handleZipFile); } else { yauzl.open(zipFilePath, {lazyEntries: true}, handleZipFile); } function openMiddleOfFile(zipFilePath, options, offsetArg, lenArg, endArg, handleZipFile) { fs.open(zipFilePath, "r", function(err, fd) { if (err != null) throw err; fs.fstat(fd, function(err, stats) { // resolve optional parameters if (offsetArg == null) offsetArg = 0; if (lenArg == null && endArg == null) endArg = stats.size; if (endArg == null) endArg = lenArg + offsetArg; else if (endArg < 0) endArg = stats.size + endArg; // validate parameters if (offsetArg < 0) throw new Error("--offset < 0"); if (lenArg < 0) throw new Error("--len < 0"); if (offsetArg > endArg) throw new Error("--offset > --end"); if (endArg > stats.size) throw new Error("--end/--len goes past EOF"); function adjustOffset(n) { return n + offsetArg; } // extend RandomAccessReader function MiddleOfFileReader() { yauzl.RandomAccessReader.call(this); } util.inherits(MiddleOfFileReader, yauzl.RandomAccessReader); // implement required and option methods MiddleOfFileReader.prototype._readStreamForRange = function(start, end) { return fs.createReadStream(null, { fd: fd, // shift the start and end offsets start: start + offsetArg, end: end + offsetArg - 1, // the -1 is because fs.createReadStream()'s end option is inclusive autoClose: false, }); }; MiddleOfFileReader.prototype.read = function(buffer, offset, length, position, callback) { // shift the position fs.read(fd, buffer, offset, length, position + offsetArg, callback); }; MiddleOfFileReader.prototype.close = function(callback) { fs.close(fd, callback); }; yauzl.fromRandomAccessReader(new MiddleOfFileReader(), endArg - offsetArg, options, handleZipFile); }); }); } function handleZipFile(err, zipfile) { if (err) throw err; // track when we've closed all our file handles var handleCount = 0; function incrementHandleCount() { handleCount++; } function decrementHandleCount() { handleCount--; if (handleCount === 0) { console.log("all input and output handles closed"); } } incrementHandleCount(); zipfile.on("close", function() { console.log("closed input file"); decrementHandleCount(); }); zipfile.readEntry(); zipfile.on("entry", function(entry) { if (/\/$/.test(entry.fileName)) { // directory file names end with '/' mkdirp(entry.fileName, function() { if (err) throw err; zipfile.readEntry(); }); } else { // ensure parent directory exists mkdirp(path.dirname(entry.fileName), function() { zipfile.openReadStream(entry, function(err, readStream) { if (err) throw err; // report progress through large files var byteCount = 0; var totalBytes = entry.uncompressedSize; var lastReportedString = byteCount + "/" + totalBytes + " 0%"; process.stdout.write(entry.fileName + "..." + lastReportedString); function reportString(msg) { var clearString = ""; for (var i = 0; i < lastReportedString.length; i++) { clearString += "\b"; if (i >= msg.length) { clearString += " \b"; } } process.stdout.write(clearString + msg); lastReportedString = msg; } // report progress at 60Hz var progressInterval = setInterval(function() { reportString(byteCount + "/" + totalBytes + " " + ((byteCount / totalBytes * 100) | 0) + "%"); }, 1000 / 60); var filter = new Transform(); filter._transform = function(chunk, encoding, cb) { byteCount += chunk.length; cb(null, chunk); }; filter._flush = function(cb) { clearInterval(progressInterval); reportString(""); // delete the "..." process.stdout.write("\b \b\b \b\b \b\n"); cb(); zipfile.readEntry(); }; // pump file contents var writeStream = fs.createWriteStream(entry.fileName); incrementHandleCount(); writeStream.on("close", decrementHandleCount); readStream.pipe(filter).pipe(writeStream); }); }); } }); } yauzl-3.4.0/fd-slicer.js000066400000000000000000000120471521126516100150740ustar00rootroot00000000000000// This was adapted from https://github.com/andrewrk/node-fd-slicer by Andrew Kelley under the MIT License. var fs = require('fs'); var util = require('util'); var stream = require('stream'); var Readable = stream.Readable; var PassThrough = stream.PassThrough; var Pend = require('pend'); var EventEmitter = require('events').EventEmitter; exports.BufferSlicer = BufferSlicer; exports.FdSlicer = FdSlicer; util.inherits(FdSlicer, EventEmitter); function FdSlicer(fd) { EventEmitter.call(this); this.fd = fd; this.pend = new Pend(); this.pend.max = 1; this.refCount = 0; } FdSlicer.prototype.read = function(buffer, offset, length, position, callback) { var self = this; self.pend.go(function(cb) { fs.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer) { cb(); callback(err, bytesRead, buffer); }); }); }; FdSlicer.prototype.createReadStream = function(options) { return new ReadStream(this, options); }; FdSlicer.prototype.ref = function() { this.refCount += 1; }; FdSlicer.prototype.unref = function() { var self = this; self.refCount -= 1; if (self.refCount < 0) throw new Error("invalid unref"); if (self.refCount > 0) return; fs.close(self.fd, onCloseDone); function onCloseDone(err) { if (err) { self.emit('error', err); } else { self.emit('close'); } } }; util.inherits(ReadStream, Readable); function ReadStream(context, options) { options = options || {}; Readable.call(this, options); this.context = context; this.context.ref(); this.start = options.start || 0; this.endOffset = options.end; this.pos = this.start; } ReadStream.prototype._read = function(n) { var self = this; var toRead = Math.min(self._readableState.highWaterMark, n); if (self.endOffset != null) { toRead = Math.min(toRead, self.endOffset - self.pos); } if (toRead <= 0) { self.push(null); this._cleanup(); return; } self.context.pend.go(function(cb) { var buffer = Buffer.allocUnsafe(toRead); fs.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) { if (err) { self.destroy(err); } else if (bytesRead === 0) { self.push(null); self._cleanup(); } else { self.pos += bytesRead; self.push(buffer.slice(0, bytesRead)); } cb(); }); }); }; ReadStream.prototype._destroy = function(err, cb) { // Node 14+ calls this automatically at EOF. this._cleanup(); cb(err); }; ReadStream.prototype._cleanup = function() { if (this.context != null) { this.context.unref(); this.context = null; } }; util.inherits(BufferSlicer, EventEmitter); function BufferSlicer(buffer) { EventEmitter.call(this); this.refCount = 0; this.buffer = buffer; } BufferSlicer.prototype.read = function(buffer, offset, length, position, callback) { if (!(0 <= offset && offset <= buffer.length)) throw new RangeError("offset outside buffer: 0 <= " + offset + " <= " + buffer.length); if (position < 0) throw new RangeError("position is negative: " + position); if (offset + length > buffer.length) { // The caller's buffer can't hold all the bytes they're trying to read. // Clamp the length instead of giving an error. // The callback will be informed of fewer than expected bytes written. length = buffer.length - offset; } if (position + length > this.buffer.length) { // Clamp any attempt to read past the end of the source buffer. length = this.buffer.length - position; } if (length <= 0) { // After any clamping, we're fully out of bounds or otherwise have nothing to do. // This isn't an error; it's just zero bytes written. setImmediate(function() { callback(null, 0); }); return; } this.buffer.copy(buffer, offset, position, position + length); setImmediate(function() { callback(null, length); }); }; BufferSlicer.prototype.createReadStream = function(options) { options = options || {}; var readStream = new PassThrough(options); readStream.start = options.start || 0; readStream.endOffset = options.end; // by the time this function returns, we'll be done. readStream.pos = readStream.endOffset || this.buffer.length; var entireSlice = this.buffer.slice(readStream.start, readStream.pos); // Cut the buffer into smaller slices for better memory usage when streaming into a zlib inflate stream. // See https://github.com/thejoshwolfe/yauzl/issues/87 var maxChunkSize = 0x10000; var offset = 0; while (true) { var nextOffset = offset + maxChunkSize; if (nextOffset >= entireSlice.length) { // last chunk if (offset < entireSlice.length) { readStream.write(entireSlice.slice(offset, entireSlice.length)); } break; } readStream.write(entireSlice.slice(offset, nextOffset)); offset = nextOffset; } readStream.end(); return readStream; }; BufferSlicer.prototype.ref = function() { this.refCount += 1; }; BufferSlicer.prototype.unref = function() { this.refCount -= 1; if (this.refCount < 0) { throw new Error("invalid unref"); } }; yauzl-3.4.0/index.js000066400000000000000000001247071521126516100143420ustar00rootroot00000000000000var fs = require("fs"); var zlib = require("zlib"); var fd_slicer = require("./fd-slicer"); var util = require("util"); var EventEmitter = require("events").EventEmitter; var Transform = require("stream").Transform; var PassThrough = require("stream").PassThrough; var Writable = require("stream").Writable; // Node 20 added zlib.crc32. const crc32 = typeof zlib.crc32 === "function" ? zlib.crc32 : require("./crc32"); exports.open = open; exports.fromFd = fromFd; exports.fromBuffer = fromBuffer; exports.fromRandomAccessReader = fromRandomAccessReader; exports.openPromise = openPromise; exports.fromFdPromise = fromFdPromise; exports.fromBufferPromise = fromBufferPromise; exports.fromRandomAccessReaderPromise = fromRandomAccessReaderPromise; exports.dosDateTimeToDate = dosDateTimeToDate; exports.getFileNameLowLevel = getFileNameLowLevel; exports.validateFileName = validateFileName; exports.parseExtraFields = parseExtraFields; exports.ZipFile = ZipFile; exports.Entry = Entry; exports.LocalFileHeader = LocalFileHeader; exports.RandomAccessReader = RandomAccessReader; function openPromise(path, options) { return new Promise((resolve, reject) => { open(path, {...options, lazyEntries: true}, function(err, zipfile) { if (err) return reject(err); resolve(zipfile); }); }); } function fromFdPromise(fd, options) { return new Promise((resolve, reject) => { fromFd(fd, {...options, lazyEntries: true}, function(err, zipfile) { if (err) return reject(err); resolve(zipfile); }); }); } function fromBufferPromise(buffer, options) { return new Promise((resolve, reject) => { fromBuffer(buffer, {...options, lazyEntries: true}, function(err, zipfile) { if (err) return reject(err); resolve(zipfile); }); }); } function fromRandomAccessReaderPromise(reader, totalSize, options) { return new Promise((resolve, reject) => { fromRandomAccessReader(reader, totalSize, {...options, lazyEntries: true}, function(err, zipfile) { if (err) return reject(err); resolve(zipfile); }); }); } function open(path, options, callback) { if (typeof options === "function") { callback = options; options = null; } if (options == null) options = {}; if (options.autoClose == null) options.autoClose = true; if (options.lazyEntries == null) options.lazyEntries = false; if (options.decodeStrings == null) options.decodeStrings = true; if (options.validateEntrySizes == null) options.validateEntrySizes = true; if (options.strictFileNames == null) options.strictFileNames = false; if (callback == null) callback = defaultCallback; fs.open(path, "r", function(err, fd) { if (err) return callback(err); fromFd(fd, options, function(err, zipfile) { if (err) fs.close(fd, defaultCallback); callback(err, zipfile); }); }); } function fromFd(fd, options, callback) { if (typeof options === "function") { callback = options; options = null; } if (options == null) options = {}; if (options.autoClose == null) options.autoClose = false; if (options.lazyEntries == null) options.lazyEntries = false; if (options.decodeStrings == null) options.decodeStrings = true; if (options.validateEntrySizes == null) options.validateEntrySizes = true; if (options.strictFileNames == null) options.strictFileNames = false; if (callback == null) callback = defaultCallback; fs.fstat(fd, function(err, stats) { if (err) return callback(err); var reader = new fd_slicer.FdSlicer(fd); fromRandomAccessReader(reader, stats.size, options, callback); }); } function fromBuffer(buffer, options, callback) { if (typeof options === "function") { callback = options; options = null; } if (options == null) options = {}; options.autoClose = false; if (options.lazyEntries == null) options.lazyEntries = false; if (options.decodeStrings == null) options.decodeStrings = true; if (options.validateEntrySizes == null) options.validateEntrySizes = true; if (options.strictFileNames == null) options.strictFileNames = false; var reader = new fd_slicer.BufferSlicer(buffer); fromRandomAccessReader(reader, buffer.length, options, callback); } function fromRandomAccessReader(reader, totalSize, options, callback) { if (typeof options === "function") { callback = options; options = null; } if (options == null) options = {}; if (options.autoClose == null) options.autoClose = true; if (options.lazyEntries == null) options.lazyEntries = false; if (options.decodeStrings == null) options.decodeStrings = true; var decodeStrings = !!options.decodeStrings; if (options.validateEntrySizes == null) options.validateEntrySizes = true; if (options.strictFileNames == null) options.strictFileNames = false; if (callback == null) callback = defaultCallback; if (typeof totalSize !== "number") throw new Error("expected totalSize parameter to be a number"); if (totalSize > Number.MAX_SAFE_INTEGER) { throw new Error("zip file too large. only file sizes up to 2^52 are supported due to JavaScript's Number type being an IEEE 754 double."); } // the matching unref() call is in zipfile.close() reader.ref(); // eocdr means End of Central Directory Record. // search backwards for the eocdr signature. // the last field of the eocdr is a variable-length comment. // the comment size is encoded in a 2-byte field in the eocdr, which we can't find without trudging backwards through the comment to find it. // as a consequence of this design decision, it's possible to have ambiguous zip file metadata if a coherent eocdr was in the comment. // we search backwards for a eocdr signature, and hope that whoever made the zip file was smart enough to forbid the eocdr signature in the comment. var eocdrWithoutCommentSize = 22; var zip64EocdlSize = 20; // Zip64 end of central directory locator var maxCommentSize = 0xffff; // 2-byte size var bufferSize = Math.min(zip64EocdlSize + eocdrWithoutCommentSize + maxCommentSize, totalSize); var buffer = newBuffer(bufferSize); var bufferReadStart = totalSize - buffer.length; readAndAssertNoEof(reader, buffer, 0, bufferSize, bufferReadStart, function(err) { if (err) return callback(err); for (var i = bufferSize - eocdrWithoutCommentSize; i >= 0; i -= 1) { if (buffer.readUInt32LE(i) !== 0x06054b50) continue; // found eocdr var eocdrBuffer = buffer.subarray(i); // 0 - End of central directory signature = 0x06054b50 // 4 - Number of this disk var diskNumber = eocdrBuffer.readUInt16LE(4); // 6 - Disk where central directory starts // 8 - Number of central directory records on this disk // 10 - Total number of central directory records var entryCount = eocdrBuffer.readUInt16LE(10); // 12 - Size of central directory (bytes) // 16 - Offset of start of central directory, relative to start of archive var centralDirectoryOffset = eocdrBuffer.readUInt32LE(16); // 20 - Comment length var commentLength = eocdrBuffer.readUInt16LE(20); var expectedCommentLength = eocdrBuffer.length - eocdrWithoutCommentSize; if (commentLength !== expectedCommentLength) { return callback(new Error("Invalid comment length. Expected: " + expectedCommentLength + ". Found: " + commentLength + ". Are there extra bytes at the end of the file? Or is the end of central dir signature `PK☺☻` in the comment?")); } // 22 - Comment // the encoding is always cp437. var comment = decodeStrings ? decodeBuffer(eocdrBuffer.subarray(22), false) : eocdrBuffer.subarray(22); // Look for a Zip64 end of central directory locator if (i - zip64EocdlSize >= 0 && buffer.readUInt32LE(i - zip64EocdlSize) === 0x07064b50) { // ZIP64 format var zip64EocdlBuffer = buffer.subarray(i - zip64EocdlSize, i - zip64EocdlSize + zip64EocdlSize); // 0 - zip64 end of central dir locator signature = 0x07064b50 // 4 - number of the disk with the start of the zip64 end of central directory // 8 - relative offset of the zip64 end of central directory record var zip64EocdrOffset = readUInt64LE(zip64EocdlBuffer, 8); // 16 - total number of disks // ZIP64 end of central directory record var zip64EocdrBuffer = newBuffer(56); return readAndAssertNoEof(reader, zip64EocdrBuffer, 0, zip64EocdrBuffer.length, zip64EocdrOffset, function(err) { if (err) return callback(err); // 0 - zip64 end of central dir signature 4 bytes (0x06064b50) if (zip64EocdrBuffer.readUInt32LE(0) !== 0x06064b50) { return callback(new Error("invalid zip64 end of central directory record signature")); } // 4 - size of zip64 end of central directory record 8 bytes // 12 - version made by 2 bytes // 14 - version needed to extract 2 bytes // 16 - number of this disk 4 bytes diskNumber = zip64EocdrBuffer.readUInt32LE(16); if (diskNumber !== 0) { // Check this only after zip64 overrides. See #118. return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber)); } // 20 - number of the disk with the start of the central directory 4 bytes // 24 - total number of entries in the central directory on this disk 8 bytes // 32 - total number of entries in the central directory 8 bytes entryCount = readUInt64LE(zip64EocdrBuffer, 32); // 40 - size of the central directory 8 bytes // 48 - offset of start of central directory with respect to the starting disk number 8 bytes centralDirectoryOffset = readUInt64LE(zip64EocdrBuffer, 48); // 56 - zip64 extensible data sector (variable size) return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames)); }); } // Not ZIP64 format if (diskNumber !== 0) { return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber)); } return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames)); } // Not a zip file. callback(new Error("End of central directory record signature not found. Either not a zip file, or file is truncated.")); }); } util.inherits(ZipFile, EventEmitter); function ZipFile(reader, centralDirectoryOffset, fileSize, entryCount, comment, autoClose, lazyEntries, decodeStrings, validateEntrySizes, strictFileNames) { var self = this; EventEmitter.call(self); self.reader = reader; // forward close events self.reader.on("error", function(err) { // error closing the fd emitError(self, err); }); self.reader.once("close", function() { self.emit("close"); }); self.readEntryCursor = centralDirectoryOffset; self.fileSize = fileSize; self.entryCount = entryCount; self.comment = comment; self.entriesRead = 0; self.autoClose = !!autoClose; self.lazyEntries = !!lazyEntries; self.decodeStrings = !!decodeStrings; self.validateEntrySizes = !!validateEntrySizes; self.strictFileNames = !!strictFileNames; self.isOpen = true; self.emittedError = false; self.hasEachEntryBeenCalled = false; if (!self.lazyEntries) self._readEntry(); } ZipFile.prototype.close = function() { if (!this.isOpen) return; this.isOpen = false; this.reader.unref(); }; function emitErrorAndAutoClose(self, err) { if (self.autoClose) self.close(); emitError(self, err); } function emitError(self, err) { if (self.emittedError) return; self.emittedError = true; self.emit("error", err); } ZipFile.prototype.readEntry = function() { if (!this.lazyEntries) throw new Error("readEntry() called without lazyEntries:true"); this._readEntry(); }; ZipFile.prototype._readEntry = function() { var self = this; if (self.entryCount === self.entriesRead) { // done with metadata setImmediate(function() { if (self.autoClose) self.close(); if (self.emittedError) return; self.emit("end"); }); return; } if (self.emittedError) return; var buffer = newBuffer(46); readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err) { if (err) return emitErrorAndAutoClose(self, err); if (self.emittedError) return; var entry = new Entry(); // 0 - Central directory file header signature var signature = buffer.readUInt32LE(0); if (signature !== 0x02014b50) return emitErrorAndAutoClose(self, new Error("invalid central directory file header signature: 0x" + signature.toString(16))); // 4 - Version made by entry.versionMadeBy = buffer.readUInt16LE(4); // 6 - Version needed to extract (minimum) entry.versionNeededToExtract = buffer.readUInt16LE(6); // 8 - General purpose bit flag entry.generalPurposeBitFlag = buffer.readUInt16LE(8); // 10 - Compression method entry.compressionMethod = buffer.readUInt16LE(10); // 12 - File last modification time entry.lastModFileTime = buffer.readUInt16LE(12); // 14 - File last modification date entry.lastModFileDate = buffer.readUInt16LE(14); // 16 - CRC-32 entry.crc32 = buffer.readUInt32LE(16); // 20 - Compressed size entry.compressedSize = buffer.readUInt32LE(20); // 24 - Uncompressed size entry.uncompressedSize = buffer.readUInt32LE(24); // 28 - File name length (n) entry.fileNameLength = buffer.readUInt16LE(28); // 30 - Extra field length (m) entry.extraFieldLength = buffer.readUInt16LE(30); // 32 - File comment length (k) entry.fileCommentLength = buffer.readUInt16LE(32); // 34 - Disk number where file starts // 36 - Internal file attributes entry.internalFileAttributes = buffer.readUInt16LE(36); // 38 - External file attributes entry.externalFileAttributes = buffer.readUInt32LE(38); // 42 - Relative offset of local file header entry.relativeOffsetOfLocalHeader = buffer.readUInt32LE(42); if (entry.generalPurposeBitFlag & 0x40) return emitErrorAndAutoClose(self, new Error("strong encryption is not supported")); self.readEntryCursor += 46; buffer = newBuffer(entry.fileNameLength + entry.extraFieldLength + entry.fileCommentLength); readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err) { if (err) return emitErrorAndAutoClose(self, err); if (self.emittedError) return; // 46 - File name entry.fileNameRaw = buffer.subarray(0, entry.fileNameLength); // 46+n - Extra field var fileCommentStart = entry.fileNameLength + entry.extraFieldLength; entry.extraFieldRaw = buffer.subarray(entry.fileNameLength, fileCommentStart); // 46+n+m - File comment entry.fileCommentRaw = buffer.subarray(fileCommentStart, fileCommentStart + entry.fileCommentLength); // Parse the extra fields, which we need for processing other fields. try { entry.extraFields = parseExtraFields(entry.extraFieldRaw); } catch (err) { return emitErrorAndAutoClose(self, err); } // Interpret strings according to bit flags, extra fields, and options. if (self.decodeStrings) { var isUtf8 = (entry.generalPurposeBitFlag & 0x800) !== 0; entry.fileComment = decodeBuffer(entry.fileCommentRaw, isUtf8); entry.fileName = getFileNameLowLevel(entry.generalPurposeBitFlag, entry.fileNameRaw, entry.extraFields, self.strictFileNames); var errorMessage = validateFileName(entry.fileName); if (errorMessage != null) return emitErrorAndAutoClose(self, new Error(errorMessage)); } else { entry.fileComment = entry.fileCommentRaw; entry.fileName = entry.fileNameRaw; } // Maintain API compatibility. See https://github.com/thejoshwolfe/yauzl/issues/47 entry.comment = entry.fileComment; self.readEntryCursor += buffer.length; self.entriesRead += 1; // Check for the Zip64 Extended Information Extra Field. for (var i = 0; i < entry.extraFields.length; i++) { var extraField = entry.extraFields[i]; if (extraField.id !== 0x0001) continue; // Found it. var zip64EiefBuffer = extraField.data; var index = 0; // 0 - Original Size 8 bytes if (entry.uncompressedSize === 0xffffffff) { if (index + 8 > zip64EiefBuffer.length) { return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include uncompressed size")); } entry.uncompressedSize = readUInt64LE(zip64EiefBuffer, index); index += 8; } // 8 - Compressed Size 8 bytes if (entry.compressedSize === 0xffffffff) { if (index + 8 > zip64EiefBuffer.length) { return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include compressed size")); } entry.compressedSize = readUInt64LE(zip64EiefBuffer, index); index += 8; } // 16 - Relative Header Offset 8 bytes if (entry.relativeOffsetOfLocalHeader === 0xffffffff) { if (index + 8 > zip64EiefBuffer.length) { return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include relative header offset")); } entry.relativeOffsetOfLocalHeader = readUInt64LE(zip64EiefBuffer, index); index += 8; } // 24 - Disk Start Number 4 bytes break; } // validate file size if (self.validateEntrySizes && entry.compressionMethod === 0) { var expectedCompressedSize = entry.uncompressedSize; if (entry.isEncrypted()) { // traditional encryption prefixes the file data with a header expectedCompressedSize += 12; } if (entry.compressedSize !== expectedCompressedSize) { var msg = "compressed/uncompressed size mismatch for stored file: " + entry.compressedSize + " != " + entry.uncompressedSize; return emitErrorAndAutoClose(self, new Error(msg)); } } self.emit("entry", entry); if (!self.lazyEntries) self._readEntry(); }); }); }; ZipFile.prototype.eachEntry = function() { const self = this; if (!self.lazyEntries) throw new Error("eachEntry() requires lazyEntries: true"); if (self.hasEachEntryBeenCalled) throw new Error("eachEntry() must only be called once per ZipFile"); self.hasEachEntryBeenCalled = true; let pendingResolveReject = null; self.on("entry", onEntry); self.on("end", onEnd); self.on("error", onError); function cleanup() { self.removeListener("entry", onEntry); self.removeListener("end", onEnd); self.removeListener("error", onError); if (self.autoClose) self.close(); } function onEntry(entry) { let {resolve} = pendingResolveReject; pendingResolveReject = null; resolve({value: entry}); } function onEnd() { let {resolve} = pendingResolveReject; pendingResolveReject = null; cleanup(); resolve({done: true}); } function onError(err) { let {reject} = pendingResolveReject; pendingResolveReject = null; cleanup(); reject(err); } return { [Symbol.asyncIterator]() { // Called once by `for await...of`. return this; }, next() { // Called on each iteration in a `for await...of`. const promise = new Promise((resolve, reject) => { if (pendingResolveReject != null) throw new Error("next() called before previous Promise was resolved."); pendingResolveReject = {resolve, reject}; }); self.readEntry(); return promise; }, return(value) { // Called when breaking, returning, throwing out of a `for await...of`. cleanup(); return Promise.resolve({done: true, value}); }, throw(value) { // Almost never called. Something about `yield*` maybe? cleanup(); return Promise.reject(value); }, }; }; ZipFile.prototype.openReadStream = function(entry, options, callback) { var self = this; // parameter validation var relativeStart = 0; var relativeEnd = entry.compressedSize; if (callback == null) { callback = options; options = null; } if (options == null) { options = {}; } else { if (options.decodeFileData === false) { // new, simple option if (options.decrypt != null) { throw new Error("cannot use options.decrypt when options.decodeFileData === false"); } if (options.decompress != null) { throw new Error("cannot use options.decompress when options.decodeFileData === false"); } // start and end are allowed } else { // old, complicated options if (options.decrypt != null) { if (!entry.isEncrypted()) { throw new Error("options.decrypt can only be specified for encrypted entries. See also option decodeFileData."); } if (options.decrypt !== false) throw new Error("invalid options.decrypt value: " + options.decrypt); if (entry.isCompressed()) { if (options.decompress !== false) throw new Error("entry is encrypted and compressed, and options.decompress !== false. See also option decodeFileData."); } } if (options.decompress != null) { if (!entry.isCompressed()) { throw new Error("options.decompress can only be specified for compressed entries. See also option decodeFileData."); } if (!(options.decompress === false || options.decompress === true)) { throw new Error("invalid options.decompress value: " + options.decompress); } decompress = options.decompress; } } if (options.start != null) { relativeStart = options.start; if (relativeStart < 0) throw new Error("options.start < 0"); if (relativeStart > entry.compressedSize) throw new Error("options.start > entry.compressedSize"); } if (options.end != null) { relativeEnd = options.end; if (relativeEnd < 0) throw new Error("options.end < 0"); if (relativeEnd > entry.compressedSize) throw new Error("options.end > entry.compressedSize"); if (relativeEnd < relativeStart) throw new Error("options.end < options.start"); } } var rawMode = ( options.decodeFileData === false || // Explicitly requested raw. ( (entry.compressionMethod === 0 || // Naturally without compression. (entry.compressionMethod === 8 && options.decompress === false) // Deprecated compression bypass option. ) && (!entry.isEncrypted() || // Naturally without encryption. options.decrypt === false // Deprecated encryption bypass option. ) ) ); if (options.start != null || options.end != null) { // Ensure slicing deals with raw data. if (!rawMode) throw new Error("start/end range require options.decodeFileData === false for non-trivial encoded entries."); } // any further errors can either be caused by the zipfile, // or were introduced in a minor version of yauzl, // so should be passed to the client rather than thrown. if (!self.isOpen) return callback(new Error("closed")); if (entry.isEncrypted() && !rawMode) { if (options.decrypt !== false) return callback(new Error("entry is encrypted, and options.decodeFileData !== false")); } var decompress; if (rawMode) { decompress = false; } else if (entry.compressionMethod === 8) { // 8 - The file is Deflated decompress = options.decodeFileData !== true; } else { return callback(new Error("unsupported compression method: " + entry.compressionMethod)); } self.readLocalFileHeader(entry, {minimal: true}, function(err, localFileHeader) { if (err) return callback(err); self.openReadStreamLowLevel( localFileHeader.fileDataStart, entry.compressedSize, relativeStart, relativeEnd, decompress, entry.uncompressedSize, callback); }); }; ZipFile.prototype.openReadStreamLowLevel = function(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress, uncompressedSize, callback) { var self = this; var fileDataEnd = fileDataStart + compressedSize; var readStream = self.reader.createReadStream({ start: fileDataStart + relativeStart, end: fileDataStart + relativeEnd, }); var endpointStream = readStream; if (decompress) { var destroyed = false; var inflateFilter = zlib.createInflateRaw(); readStream.on("error", function(err) { // setImmediate here because errors can be emitted during the first call to pipe() setImmediate(function() { if (!destroyed) inflateFilter.emit("error", err); }); }); readStream.pipe(inflateFilter); if (self.validateEntrySizes) { endpointStream = new AssertByteCountStream(uncompressedSize); inflateFilter.on("error", function(err) { // forward zlib errors to the client-visible stream setImmediate(function() { if (!destroyed) endpointStream.emit("error", err); }); }); inflateFilter.pipe(endpointStream); } else { // the zlib filter is the client-visible stream endpointStream = inflateFilter; } // this is part of yauzl's API, so implement this function on the client-visible stream installDestroyFn(endpointStream, function() { destroyed = true; if (inflateFilter !== endpointStream) inflateFilter.unpipe(endpointStream); readStream.unpipe(inflateFilter); // TODO: the inflateFilter may cause a memory leak. see Issue #27. readStream.destroy(); }); } callback(null, endpointStream); }; ZipFile.prototype.readLocalFileHeader = function(entry, options, callback) { var self = this; if (callback == null) { callback = options; options = null; } if (options == null) options = {}; self.reader.ref(); var buffer = newBuffer(30); readAndAssertNoEof(self.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader, function(err) { try { if (err) return callback(err); // 0 - Local file header signature = 0x04034b50 var signature = buffer.readUInt32LE(0); if (signature !== 0x04034b50) { return callback(new Error("invalid local file header signature: 0x" + signature.toString(16))); } var fileNameLength = buffer.readUInt16LE(26); var extraFieldLength = buffer.readUInt16LE(28); var fileDataStart = entry.relativeOffsetOfLocalHeader + 30 + fileNameLength + extraFieldLength; // We now have enough information to do this bounds check. if (fileDataStart + entry.compressedSize > self.fileSize) { return callback(new Error("file data overflows file bounds: " + fileDataStart + " + " + entry.compressedSize + " > " + self.fileSize)); } if (options.minimal) { return callback(null, {fileDataStart: fileDataStart}); } var localFileHeader = new LocalFileHeader(); localFileHeader.fileDataStart = fileDataStart; // 4 - Version needed to extract (minimum) localFileHeader.versionNeededToExtract = buffer.readUInt16LE(4); // 6 - General purpose bit flag localFileHeader.generalPurposeBitFlag = buffer.readUInt16LE(6); // 8 - Compression method localFileHeader.compressionMethod = buffer.readUInt16LE(8); // 10 - File last modification time localFileHeader.lastModFileTime = buffer.readUInt16LE(10); // 12 - File last modification date localFileHeader.lastModFileDate = buffer.readUInt16LE(12); // 14 - CRC-32 localFileHeader.crc32 = buffer.readUInt32LE(14); // 18 - Compressed size localFileHeader.compressedSize = buffer.readUInt32LE(18); // 22 - Uncompressed size localFileHeader.uncompressedSize = buffer.readUInt32LE(22); // 26 - File name length (n) localFileHeader.fileNameLength = fileNameLength; // 28 - Extra field length (m) localFileHeader.extraFieldLength = extraFieldLength; // 30 - File name // 30+n - Extra field buffer = newBuffer(fileNameLength + extraFieldLength); self.reader.ref(); readAndAssertNoEof(self.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader + 30, function(err) { try { if (err) return callback(err); localFileHeader.fileName = buffer.subarray(0, fileNameLength); localFileHeader.extraField = buffer.subarray(fileNameLength); return callback(null, localFileHeader); } finally { self.reader.unref(); } }); } finally { self.reader.unref(); } }); }; ZipFile.prototype.openReadStreamPromise = function(entry, options) { return new Promise((resolve, reject) => { this.openReadStream(entry, options, function(err, readStream) { if (err) return reject(err); resolve(readStream); }); }); }; ZipFile.prototype.openReadStreamLowLevelPromise = function(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress, uncompressedSize) { return new Promise((resolve, reject) => { this.openReadStream(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress, uncompressedSize, function(err, readStream) { if (err) return reject(err); resolve(readStream); }); }); }; ZipFile.prototype.readLocalFileHeaderPromise = function(entry, options) { return new Promise((resolve, reject) => { this.readLocalFileHeader(entry, options, function(err, localFileHeader) { if (err) return reject(err); resolve(localFileHeader); }); }); }; function Entry() { } Entry.prototype.getLastModDate = function(options) { if (options == null) options = {}; if (!options.forceDosFormat) { // Check extended fields. for (var i = 0; i < this.extraFields.length; i++) { var extraField = this.extraFields[i]; if (extraField.id === 0x5455) { // Info-ZIP "universal timestamp" extended field (`0x5455` aka `"UT"`). // See the Info-ZIP source code unix/unix.c:set_extra_field() and zipfile.c:ef_scan_ut_time(). var data = extraField.data; if (data.length < 5) continue; // Too short. // The flags define which of the three fields are present: mtime, atime, ctime. // We only care about mtime. // Also, ctime is never included in practice. // And also, atime is only included in the local file header for some reason // despite the flags lying about its inclusion in the central header. var flags = data[0]; var HAS_MTIME = 1; if (!(flags & HAS_MTIME)) continue; // This will realistically never happen. // Although the positions of all of the fields shift around depending on the presence of other fields, // mtime is always first if present, and that's the only one we care about. var posixTimestamp = data.readInt32LE(1); return new Date(posixTimestamp * 1000); } else if (extraField.id === 0x000a) { var data = extraField.data; if (data.length !== 32) continue; // The length is always the same. // 4 bytes reserved // 2 bytes Tag if (data.readUInt16LE(4) !== 1) continue; // Tag1 is actually the only defined Tag. // 2 bytes Size if (data.readUInt16LE(6) !== 24) continue; // Size is always 24. // 8 bytes Mtime var hundredNanoSecondsSince1601 = data.readUInt32LE(8) + 4294967296 * data.readInt32LE(12); // Convert from NTFS to POSIX milliseconds. // The big number below is the milliseconds between year 1601 and year 1970 // (i.e. the negative POSIX timestamp of 1601-01-01 00:00:00Z) var millisecondsSince1970 = hundredNanoSecondsSince1601 / 10000 - 11644473600000; // Note on numeric precision: JavaScript Number objects lose precision above Number.MAX_SAFE_INTEGER, // and NTFS timestamps are typically much bigger than that limit. // (MAX_SAFE_INTEGER would represent 1629-07-17T23:58:45.475Z.) // However, we're losing precision in the conversion from 100nanosecond units to millisecond units anyway, // and the time at which we also lose 1-millisecond precision is year 275760, the JavaScript Date limit (by design). // Up through the year 2057, this conversion only drops 4 bits of precision, // which is well under the 13-14 bits ratio between the milliseconds and 100nanoseconds. return new Date(millisecondsSince1970); } } } // Fallback to non-extended encoding. return dosDateTimeToDate(this.lastModFileDate, this.lastModFileTime, options.timezone); }; Entry.prototype.canDecodeFileData = function() { return ( !this.isEncrypted() && (this.compressionMethod === 0 || this.compressionMethod === 8) ); }; Entry.prototype.isEncrypted = function() { return (this.generalPurposeBitFlag & 0x1) !== 0; }; Entry.prototype.isCompressed = function() { return this.compressionMethod === 8; }; function LocalFileHeader() { } function dosDateTimeToDate(date, time, timezone) { var day = date & 0x1f; // 1-31 var month = (date >> 5 & 0xf) - 1; // 1-12, 0-11 var year = (date >> 9 & 0x7f) + 1980; // 0-128, 1980-2108 var millisecond = 0; var second = (time & 0x1f) * 2; // 0-29, 0-58 (even numbers) var minute = time >> 5 & 0x3f; // 0-59 var hour = time >> 11 & 0x1f; // 0-23 if (timezone == null || timezone === "local") { return new Date(year, month, day, hour, minute, second, millisecond); } else if (timezone === "UTC") { return new Date(Date.UTC(year, month, day, hour, minute, second, millisecond)); } else { throw new Error("unrecognized options.timezone: " + options.timezone); } } function getFileNameLowLevel(generalPurposeBitFlag, fileNameBuffer, extraFields, strictFileNames) { var fileName = null; // check for Info-ZIP Unicode Path Extra Field (0x7075) // see https://github.com/thejoshwolfe/yauzl/issues/33 for (var i = 0; i < extraFields.length; i++) { var extraField = extraFields[i]; if (extraField.id === 0x7075) { if (extraField.data.length < 6) { // too short to be meaningful continue; } // Version 1 byte version of this extra field, currently 1 if (extraField.data.readUInt8(0) !== 1) { // > Changes may not be backward compatible so this extra // > field should not be used if the version is not recognized. continue; } // NameCRC32 4 bytes File Name Field CRC32 Checksum var oldNameCrc32 = extraField.data.readUInt32LE(1); if (crc32(fileNameBuffer) !== oldNameCrc32) { // > If the CRC check fails, this UTF-8 Path Extra Field should be // > ignored and the File Name field in the header should be used instead. continue; } // UnicodeName Variable UTF-8 version of the entry File Name fileName = decodeBuffer(extraField.data.subarray(5), true); break; } } if (fileName == null) { // The typical case. var isUtf8 = (generalPurposeBitFlag & 0x800) !== 0; fileName = decodeBuffer(fileNameBuffer, isUtf8); } if (!strictFileNames) { // Allow backslash. fileName = fileName.replace(/\\/g, "/"); } return fileName; } function validateFileName(fileName) { if (fileName.indexOf("\\") !== -1) { return "invalid characters in fileName: " + fileName; } if (/^[a-zA-Z]:/.test(fileName) || /^\//.test(fileName)) { return "absolute path: " + fileName; } if (fileName.split("/").indexOf("..") !== -1) { return "invalid relative path: " + fileName; } // all good return null; } function parseExtraFields(extraFieldBuffer) { var extraFields = []; var i = 0; while (i < extraFieldBuffer.length - 3) { var headerId = extraFieldBuffer.readUInt16LE(i + 0); var dataSize = extraFieldBuffer.readUInt16LE(i + 2); var dataStart = i + 4; var dataEnd = dataStart + dataSize; if (dataEnd > extraFieldBuffer.length) throw new Error("extra field length exceeds extra field buffer size"); var dataBuffer = extraFieldBuffer.subarray(dataStart, dataEnd); extraFields.push({ id: headerId, data: dataBuffer, }); i = dataEnd; } return extraFields; } function readAndAssertNoEof(reader, buffer, offset, length, position, callback) { if (length === 0) { // fs.read will throw an out-of-bounds error if you try to read 0 bytes from a 0 byte file return setImmediate(function() { callback(null, newBuffer(0)); }); } reader.read(buffer, offset, length, position, function(err, bytesRead) { if (err) return callback(err); if (bytesRead < length) { return callback(new Error("unexpected EOF")); } callback(); }); } util.inherits(AssertByteCountStream, Transform); function AssertByteCountStream(byteCount) { Transform.call(this); this.actualByteCount = 0; this.expectedByteCount = byteCount; } AssertByteCountStream.prototype._transform = function(chunk, encoding, cb) { this.actualByteCount += chunk.length; if (this.actualByteCount > this.expectedByteCount) { var msg = "too many bytes in the stream. expected " + this.expectedByteCount + ". got at least " + this.actualByteCount; return cb(new Error(msg)); } cb(null, chunk); }; AssertByteCountStream.prototype._flush = function(cb) { if (this.actualByteCount < this.expectedByteCount) { var msg = "not enough bytes in the stream. expected " + this.expectedByteCount + ". got only " + this.actualByteCount; return cb(new Error(msg)); } cb(); }; util.inherits(RandomAccessReader, EventEmitter); function RandomAccessReader() { EventEmitter.call(this); this.refCount = 0; } RandomAccessReader.prototype.ref = function() { this.refCount += 1; }; RandomAccessReader.prototype.unref = function() { var self = this; self.refCount -= 1; if (self.refCount > 0) return; if (self.refCount < 0) throw new Error("invalid unref"); self.close(onCloseDone); function onCloseDone(err) { if (err) return self.emit('error', err); self.emit('close'); } }; RandomAccessReader.prototype.createReadStream = function(options) { if (options == null) options = {}; var start = options.start; var end = options.end; if (start === end) { var emptyStream = new PassThrough(); setImmediate(function() { emptyStream.end(); }); return emptyStream; } var stream = this._readStreamForRange(start, end); var destroyed = false; var refUnrefFilter = new RefUnrefFilter(this); stream.on("error", function(err) { setImmediate(function() { if (!destroyed) refUnrefFilter.emit("error", err); }); }); installDestroyFn(refUnrefFilter, function() { stream.unpipe(refUnrefFilter); refUnrefFilter.unref(); stream.destroy(); }); var byteCounter = new AssertByteCountStream(end - start); refUnrefFilter.on("error", function(err) { setImmediate(function() { if (!destroyed) byteCounter.emit("error", err); }); }); installDestroyFn(byteCounter, function() { destroyed = true; refUnrefFilter.unpipe(byteCounter); refUnrefFilter.destroy(); }); return stream.pipe(refUnrefFilter).pipe(byteCounter); }; RandomAccessReader.prototype._readStreamForRange = function(start, end) { throw new Error("not implemented"); }; RandomAccessReader.prototype.read = function(buffer, offset, length, position, callback) { var readStream = this.createReadStream({start: position, end: position + length}); var writeStream = new Writable(); var written = 0; writeStream._write = function(chunk, encoding, cb) { chunk.copy(buffer, offset + written, 0, chunk.length); written += chunk.length; cb(); }; writeStream.on("finish", callback); readStream.on("error", function(error) { callback(error); }); readStream.pipe(writeStream); }; RandomAccessReader.prototype.close = function(callback) { setImmediate(callback); }; util.inherits(RefUnrefFilter, PassThrough); function RefUnrefFilter(context) { PassThrough.call(this); this.context = context; this.context.ref(); this.unreffedYet = false; } RefUnrefFilter.prototype._flush = function(cb) { this.unref(); cb(); }; RefUnrefFilter.prototype.unref = function(cb) { if (this.unreffedYet) return; this.unreffedYet = true; this.context.unref(); }; var cp437 = '\u0000☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ '; function decodeBuffer(buffer, isUtf8) { if (isUtf8) { return buffer.toString("utf8"); } else { var result = ""; for (var i = 0; i < buffer.length; i++) { result += cp437[buffer[i]]; } return result; } } function readUInt64LE(buffer, offset) { // There is no native function for this, because we can't actually store 64-bit integers precisely. // after 53 bits, JavaScript's Number type (IEEE 754 double) can't store individual integers anymore. // but since 53 bits is a whole lot more than 32 bits, we do our best anyway. // As of 2020, Node has added support for BigInt, which obviates this whole function, // but yauzl hasn't been updated to depend on BigInt (yet?). var lower32 = buffer.readUInt32LE(offset); var upper32 = buffer.readUInt32LE(offset + 4); // we can't use bitshifting here, because JavaScript bitshifting only works on 32-bit integers. return upper32 * 0x100000000 + lower32; // as long as we're bounds checking the result of this function against the total file size, // we'll catch any overflow errors, because we already made sure the total file size was within reason. } // Node 10 deprecated new Buffer(). var newBuffer; if (typeof Buffer.allocUnsafe === "function") { newBuffer = function(len) { return Buffer.allocUnsafe(len); }; } else { newBuffer = function(len) { return new Buffer(len); }; } // Node 8 introduced a proper destroy() implementation on writable streams. function installDestroyFn(stream, fn) { if (typeof stream.destroy === "function") { // New API. stream._destroy = function(err, cb) { fn(); if (cb != null) cb(err); }; } else { // Old API. stream.destroy = fn; } } function defaultCallback(err) { if (err) throw err; } yauzl-3.4.0/package-lock.json000066400000000000000000000166431521126516100161100ustar00rootroot00000000000000{ "name": "yauzl", "version": "3.4.0", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "yauzl", "version": "3.4.0", "license": "MIT", "dependencies": { "pend": "~1.2.0" }, "devDependencies": { "bl": "^6.0.11" }, "engines": { "node": ">=12" } }, "node_modules/@types/node": { "version": "20.11.17", "resolved": "https://registry.npmjs.org/@types/node/-/node-20.11.17.tgz", "integrity": "sha512-QmgQZGWu1Yw9TDyAP9ZzpFJKynYNeOvwMJmaxABfieQoVoiVOS6MN1WSpqpRcbeA5+RW82kraAVxCCJg+780Qw==", "dev": true, "dependencies": { "undici-types": "~5.26.4" } }, "node_modules/@types/readable-stream": { "version": "4.0.10", "resolved": "https://registry.npmjs.org/@types/readable-stream/-/readable-stream-4.0.10.tgz", "integrity": "sha512-AbUKBjcC8SHmImNi4yK2bbjogQlkFSg7shZCcicxPQapniOlajG8GCc39lvXzCWX4lLRRs7DM3VAeSlqmEVZUA==", "dev": true, "dependencies": { "@types/node": "*", "safe-buffer": "~5.1.1" } }, "node_modules/abort-controller": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz", "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==", "dev": true, "dependencies": { "event-target-shim": "^5.0.0" }, "engines": { "node": ">=6.5" } }, "node_modules/base64-js": { "version": "1.5.1", "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", "dev": true, "funding": [ { "type": "github", "url": "https://github.com/sponsors/feross" }, { "type": "patreon", "url": "https://www.patreon.com/feross" }, { "type": "consulting", "url": "https://feross.org/support" } ] }, "node_modules/bl": { "version": "6.0.11", "resolved": "https://registry.npmjs.org/bl/-/bl-6.0.11.tgz", "integrity": "sha512-Ok/NWrEA0mlEEbWzckkZVLq6Nv1m2xZ+i9Jq5hZ9Ph/YEcP5dExqls9wUzpluhQRPzdeT8oZNOXAytta6YN8pQ==", "dev": true, "dependencies": { "@types/readable-stream": "^4.0.0", "buffer": "^6.0.3", "inherits": "^2.0.4", "readable-stream": "^4.2.0" } }, "node_modules/buffer": { "version": "6.0.3", "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz", "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==", "dev": true, "funding": [ { "type": "github", "url": "https://github.com/sponsors/feross" }, { "type": "patreon", "url": "https://www.patreon.com/feross" }, { "type": "consulting", "url": "https://feross.org/support" } ], "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.2.1" } }, "node_modules/event-target-shim": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz", "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==", "dev": true, "engines": { "node": ">=6" } }, "node_modules/events": { "version": "3.3.0", "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz", "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==", "dev": true, "engines": { "node": ">=0.8.x" } }, "node_modules/ieee754": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", "dev": true, "funding": [ { "type": "github", "url": "https://github.com/sponsors/feross" }, { "type": "patreon", "url": "https://www.patreon.com/feross" }, { "type": "consulting", "url": "https://feross.org/support" } ] }, "node_modules/inherits": { "version": "2.0.4", "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", "dev": true }, "node_modules/pend": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz", "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==" }, "node_modules/process": { "version": "0.11.10", "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz", "integrity": "sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==", "dev": true, "engines": { "node": ">= 0.6.0" } }, "node_modules/readable-stream": { "version": "4.5.2", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-4.5.2.tgz", "integrity": "sha512-yjavECdqeZ3GLXNgRXgeQEdz9fvDDkNKyHnbHRFtOr7/LcfgBcmct7t/ET+HaCTqfh06OzoAxrkN/IfjJBVe+g==", "dev": true, "dependencies": { "abort-controller": "^3.0.0", "buffer": "^6.0.3", "events": "^3.3.0", "process": "^0.11.10", "string_decoder": "^1.3.0" }, "engines": { "node": "^12.22.0 || ^14.17.0 || >=16.0.0" } }, "node_modules/safe-buffer": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", "dev": true }, "node_modules/string_decoder": { "version": "1.3.0", "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", "dev": true, "dependencies": { "safe-buffer": "~5.2.0" } }, "node_modules/string_decoder/node_modules/safe-buffer": { "version": "5.2.1", "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", "dev": true, "funding": [ { "type": "github", "url": "https://github.com/sponsors/feross" }, { "type": "patreon", "url": "https://www.patreon.com/feross" }, { "type": "consulting", "url": "https://feross.org/support" } ] }, "node_modules/undici-types": { "version": "5.26.5", "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz", "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==", "dev": true } } } yauzl-3.4.0/package.json000066400000000000000000000013721521126516100151530ustar00rootroot00000000000000{ "name": "yauzl", "version": "3.4.0", "description": "yet another unzip library for node", "engines": { "node": ">=12" }, "main": "index.js", "scripts": { "test": "node test/test.js" }, "repository": { "type": "git", "url": "git+https://github.com/thejoshwolfe/yauzl.git" }, "keywords": [ "unzip", "zip", "stream", "archive", "file" ], "author": "Josh Wolfe ", "license": "MIT", "bugs": { "url": "https://github.com/thejoshwolfe/yauzl/issues" }, "homepage": "https://github.com/thejoshwolfe/yauzl", "dependencies": { "pend": "~1.2.0" }, "devDependencies": { "bl": "^6.0.11" }, "files": [ "crc32.js", "fd-slicer.js", "index.js" ] } yauzl-3.4.0/test/000077500000000000000000000000001521126516100136415ustar00rootroot00000000000000yauzl-3.4.0/test/errors.js000066400000000000000000000125361521126516100155220ustar00rootroot00000000000000// Test I/O errors coming from the random access reader at any given moment. // The .zip file being tested has a variety of features, such as a large central directory, // and somewhat large compressed and uncompressed files. const yauzl = require("../"); const path = require("path"); const fs = require("fs"); const stream = require("stream"); exports.runTest = runTest; let ArrayFromAsync = Array.fromAsync; if (typeof ArrayFromAsync !== "function") { ArrayFromAsync = async function(items) { // This is not a general-purpose polyfill. // It just does enough for what we want here. const result = []; for await (let item of items) { result.push(item); } return result; }; } class EventuallyFailRandomAccessReader extends yauzl.RandomAccessReader { constructor(successCount, buffer) { super(); this.successCount = successCount; this.buffer = buffer; } isItTimeToFail() { if (this.successCount <= 0) return true; this.successCount--; return false; } _readStreamForRange(start, end) { const self = this; const reader = new stream.Readable(); reader._read = function(size) { if (self.isItTimeToFail()) return this.emit("error", new TheErrorWeExpect("i've decided to fail now")); const clampedEnd = Math.min(start + size, end); const chunk = self.buffer.slice(start, clampedEnd); start = clampedEnd; this.push(chunk); if (start >= end) { return this.push(null); // EOF } }; return reader; } close(cb) { this.buffer = null; cb(); } } class TheErrorWeExpect extends Error {} const stopAtEntryFileName = "a/b/020"; function runTest(cb) { const buffer = fs.readFileSync(path.join(__dirname, "success", "everything.zip")); testErrorsWithCallbacks(buffer, async function() { await testErrorsWithPromises(buffer); await testErrorsWithPromisesGreedy(buffer); cb(); }); } function testErrorsWithCallbacks(buffer, cb) { const prefix = "test every error with callbacks: "; let successCount = 0; giveItAGo(function handleResult(reachedEnd) { if (reachedEnd) return cb(); successCount++; giveItAGo(handleResult); }); function giveItAGo(cb) { function handleError(err) { if (err instanceof TheErrorWeExpect) return cb(false); throw err; } const reader = new EventuallyFailRandomAccessReader(successCount, buffer); yauzl.fromRandomAccessReader(reader, buffer.length, {lazyEntries:true}, function(err, zipfile) { if (err) return handleError(err); zipfile.readEntry(); zipfile.on("error", handleError); zipfile.on("entry", function(entry) { if (entry.fileName === stopAtEntryFileName) { // We've seen enough. Don't need to fully process each small entry. return done(); } zipfile.openReadStream(entry, function(err, readStream) { if (err) return handleError(err); readStream.on("error", handleError); const sink = new stream.Writable(); sink._write = function(chunk, encoding, callback) { callback(); }; sink.on("finish", function() { zipfile.readEntry(); }); readStream.pipe(sink); }); }); zipfile.on("end", function() { throw new Error("expected to interrupt before reaching the end"); }); function done() { console.log(prefix + `done after ${successCount} read() calls`); cb(true); } }); } } async function testErrorsWithPromises(buffer) { const prefix = "test every error with promises: "; for (var successCount = 0;; successCount++) { const reader = new EventuallyFailRandomAccessReader(successCount, buffer); try { const zipfile = await yauzl.fromRandomAccessReaderPromise(reader, buffer.length); for await (let entry of zipfile.eachEntry()) { if (entry.fileName == stopAtEntryFileName) break; const readStream = await zipfile.openReadStreamPromise(entry); for await (let chunk of readStream) { // Do nothing. } } } catch (err) { handleError(err); continue; } break; } console.log(prefix + `done after ${successCount} read() calls`); function handleError(err) { if (err instanceof TheErrorWeExpect) return; throw err; } } async function testErrorsWithPromisesGreedy(buffer) { const prefix = "test almost every error with greedy promises: "; for (var successCount = 0;; successCount += Math.max(1, successCount >> 2)) { var reader = new EventuallyFailRandomAccessReader(successCount, buffer); try { const zipfile = await yauzl.fromRandomAccessReaderPromise(reader, buffer.length, {autoClose: false}); try { // All entries are read first, then all read streams are opened afterward. const entries = await ArrayFromAsync(zipfile.eachEntry()); for (let entry of entries) { const readStream = await zipfile.openReadStreamPromise(entry); for await (let chunk of readStream) { // Do nothing. } } } finally { zipfile.close(); } } catch (err) { handleError(err); continue; } break; } console.log(prefix + `done after ${successCount - reader.successCount} read() calls`); function handleError(err) { if (err instanceof TheErrorWeExpect) return; throw err; } } yauzl-3.4.0/test/failure/000077500000000000000000000000001521126516100152705ustar00rootroot00000000000000End of central directory record signature not found Either not a zip file or file is truncated.zip000066400000000000000000000004641521126516100372450ustar00rootroot00000000000000yauzl-3.4.0/test/failurePK KEQVa.txtUT >*S>*Sux asdf PK KEb.txtUT >*S>*Sux bsdf PK KEQVa.txtUT>*Sux PK KEDb.txtUT>*Sux PKEnd of central directory record signature not found Either not a zip file or file is truncated_1.zip000066400000000000000000000000001521126516100374470ustar00rootroot00000000000000yauzl-3.4.0/test/failure64cca97da08d4c96c19675cedb5284a402d60867.paxheader00006660000000000000000000000262152112651610020450xustar00rootroot00000000000000178 path=yauzl-3.4.0/test/failure/Invalid comment length Expected 1 Found 0 Are there extra bytes at the end of the file Or is the end of central dir signature PK in the com.zip 64cca97da08d4c96c19675cedb5284a402d60867.data000066400000000000000000000004651521126516100173130ustar00rootroot00000000000000PK KEQVa.txtUT >*S>*Sux asdf PK KEb.txtUT >*S>*Sux bsdf PK KEQVa.txtUT>*Sux PK KEDb.txtUT>*Sux PKyauzl-3.4.0/test/failure/absolute path C xt.zip000066400000000000000000000004641521126516100213320ustar00rootroot00000000000000PK KEQVa.txtUT >*S>*Sux asdf PK KEb.txtUT >*S>*Sux bsdf PK KEQVC:/xtUT>*Sux PK KEDb.txtUT>*Sux PKyauzl-3.4.0/test/failure/absolute path atxt.zip000066400000000000000000000004641521126516100215140ustar00rootroot00000000000000PK KEQVa.txtUT >*S>*Sux asdf PK KEb.txtUT >*S>*Sux bsdf PK KEQV/atxtUT>*Sux PK KEDb.txtUT>*Sux PKyauzl-3.4.0/test/failure/compressed uncompressed size mismatch for stored file 2147483647 5.zip000066400000000000000000000004641521126516100315300ustar00rootroot00000000000000PK KEQVa.txtUT >*S>*Sux asdf PK KEb.txtUT >*S>*Sux bsdf PK KEQVa.txtUT>*Sux PK KEDb.txtUT>*Sux PKyauzl-3.4.0/test/failure/extra field length exceeds extra field buffer size.zip000066400000000000000000000004641521126516100274070ustar00rootroot00000000000000PK KEQVa.txtUT >*S>*Sux asdf PK KEb.txtUT >*S>*Sux bsdf PK KEQVa.txtUT>*Sux PK KEDb.txtUT>*Sux PKyauzl-3.4.0/test/failure/file data overflows file bounds 63 2147483647 308.zip000066400000000000000000000004641521126516100255750ustar00rootroot00000000000000PK KEQVa.txtUT >*S>*Sux asdf PK KEb.txtUT >*S>*Sux bsdf PK KEQVa.txtUT>*Sux PK KEDb.txtUT>*Sux PKyauzl-3.4.0/test/failure/invalid central directory file header signature 0x1014b50.zip000066400000000000000000000004641521126516100302640ustar00rootroot00000000000000PK KEQVa.txtUT >*S>*Sux asdf PK KEb.txtUT >*S>*Sux bsdf PK KEQVa.txtUT>*Sux PK KEDb.txtUT>*Sux PKyauzl-3.4.0/test/failure/invalid characters in fileName a txt.zip000066400000000000000000000004641521126516100246370ustar00rootroot00000000000000PK KEQVa.txtUT >*S>*Sux asdf PK KEb.txtUT >*S>*Sux bsdf PK KEQVa\txtUT>*Sux PK KEDb.txtUT>*Sux PKyauzl-3.4.0/test/failure/invalid code lengths set.zip000066400000000000000000000056611521126516100225460ustar00rootroot00000000000000PK E )index.jsUT WSWSux [o~C#ۺUov\IZ" $Ų69s 9dj 9sΙ܇z 5+p>%,MJ..H YU A%򑆼rIsEg4`˶}4HH<Z"K ۪.ء t;Cd MzE@LQOK%Q¬72I%֎ir: ҲU(d~ ,Q=漨J5#~ ?ڍI$&4OoI2"8V=&RAq8 ,64CyX>aK*63ْf~SXlC*< {4(8 A}PD%\ RFJCj/$\M"11 =+I@ ͱ`IBmIS@=SEG4",PQc߱pG ^ A{ zsDV\ncF 4PVDY xaӫ,YJtö5Kt^CRZQP`>iб"Aۃxu6TpPi$bVUN8{4eDe"qda^ J OhX U< ~xHentaS1-;HӔ;o P11Eu)0螼 ABV<-wa~y,SlldfƱ'i0^0D]hg5(srC헬Z.وqv9q +DIŲ6ɤ{qx&0ϰ9aC{km"@(Zkkno_uA&Y([5ZYg@]?؍HcCtpBgbqHuŅFD*2[bȲ]ziƇ\9twg, tq2J>J5}Ê aei ^%]6f" [V*)^ pjUcd(y8l߉-7Iyb"V,{$x#$ +}U?(zJsˮx;Y.l pe&{ J [rNeaf*{X5sFK1fK8 op(㥅xR~i+ܞe-?ZP9$cHN,h *H1&GK HP߿>U,Y^IN  B?Y6(%LEڿ뗸ZR Y]*_y~\W(nvة,< ױL'(sW+U|5 0e݇k$O\ŕ7u3KBt8LZ脅<{*MHl 37WXXXԷ/rY_;8ݼ-3@6CFQDVe嵳I ߾*޼mVp77ṑإ} mMmI)(ıV6 &]`sdvmi۬=Y:3m&)וV}Dͭu'Gӝٗt= }sgscFN=Z2@ޝW8ނ .:|G?YySvmX͖-w\a (: Фfz=ݜCN+fУ5࣫_(w\<ֈrx lGp.w{[Qp( CFV]w{+iU\mj:}؊X%b#uflG~mc;,w]wh%ζH9%6{ ; ;9f^ o}C] 0k[]@[*]̕~5V}/^p/ӹIRė2gukC%@<5ԝQ7G ]2-*loOk]6EPK E )index.jsUTWSux PKNM yauzl-3.4.0/test/failure/invalid local file header signature 0x3034b50.zip000066400000000000000000000004641521126516100257450ustar00rootroot00000000000000PK KEQVa.txtUT >*S>*Sux asdf PK KEb.txtUT >*S>*Sux bsdf PK KEQVa.txtUT>*Sux PK KEDb.txtUT>*Sux PKyauzl-3.4.0/test/failure/invalid relative path xt.zip000066400000000000000000000004641521126516100225730ustar00rootroot00000000000000PK KEQVa.txtUT >*S>*Sux asdf PK KEb.txtUT >*S>*Sux bsdf PK KEQV../xtUT>*Sux PK KEDb.txtUT>*Sux PKyauzl-3.4.0/test/failure/invalid zip64 end of central directory record signature.zip000066400000000000000000000001421521126516100303270ustar00rootroot00000000000000PK,?-PKPKyauzl-3.4.0/test/failure/multi-disk zip files are not supported found disk number 1.zip000066400000000000000000000004641521126516100306700ustar00rootroot00000000000000PK KEQVa.txtUT >*S>*Sux asdf PK KEb.txtUT >*S>*Sux bsdf PK KEQVa.txtUT>*Sux PK KEDb.txtUT>*Sux PKyauzl-3.4.0/test/failure/not enough bytes in the stream expected 2048576 got only 1000000.zip000066400000000000000000000022011521126516100304670ustar00rootroot00000000000000PKGFy@B zeros.binUT e!@U\!@Uux  nH@PKGFy@B zeros.binUTe!@Uux PKOyauzl-3.4.0/test/failure/strong encryption is not supported.zip000066400000000000000000000003021521126516100246610ustar00rootroot00000000000000PK J 0:6a.txtUT :XEXux (=0X&]b\PK 0:6PK IJ 0:6a.txtUT:Xux PKKayauzl-3.4.0/test/failure/too many bytes in the stream expected 82496 got at least 98304.zip000066400000000000000000000022011521126516100304070ustar00rootroot00000000000000PKGFy@B zeros.binUT e!@U\!@Uux  nH@PKGFy@B zeros.binUTe!@Uux PKOyauzl-3.4.0/test/failure/too many length or distance symbols.zip000066400000000000000000000056611521126516100246410ustar00rootroot00000000000000PK E )index.jsUT WSWSux Z[o~C#ۺUov\IZ" $Ų69s 9dj 9sΙ܇z 5+p>%,MJ..H YU A%򑆼rIsEg4`˶}4HH<Z"K ۪.ء t;Cd MzE@LQOK%Q¬72I%֎ir: ҲU(d~ ,Q=漨J5#~ ?ڍI$&4OoI2"8V=&RAq8 ,64CyX>aK*63ْf~SXlC*< {4(8 A}PD%\ RFJCj/$\M"11 =+I@ ͱ`IBmIS@=SEG4",PQc߱pG ^ A{ zsDV\ncF 4PVDY xaӫ,YJtö5Kt^CRZQP`>iб"Aۃxu6TpPi$bVUN8{4eDe"qda^ J OhX U< ~xHentaS1-;HӔ;o P11Eu)0螼 ABV<-wa~y,SlldfƱ'i0^0D]hg5(srC헬Z.وqv9q +DIŲ6ɤ{qx&0ϰ9aC{km"@(Zkkno_uA&Y([5ZYg@]?؍HcCtpBgbqHuŅFD*2[bȲ]ziƇ\9twg, tq2J>J5}Ê aei ^%]6f" [V*)^ pjUcd(y8l߉-7Iyb"V,{$x#$ +}U?(zJsˮx;Y.l pe&{ J [rNeaf*{X5sFK1fK8 op(㥅xR~i+ܞe-?ZP9$cHN,h *H1&GK HP߿>U,Y^IN  B?Y6(%LEڿ뗸ZR Y]*_y~\W(nvة,< ױL'(sW+U|5 0e݇k$O\ŕ7u3KBt8LZ脅<{*MHl 37WXXXԷ/rY_;8ݼ-3@6CFQDVe嵳I ߾*޼mVp77ṑإ} mMmI)(ıV6 &]`sdvmi۬=Y:3m&)וV}Dͭu'Gӝٗt= }sgscFN=Z2@ޝW8ނ .:|G?YySvmX͖-w\a (: Фfz=ݜCN+fУ5࣫_(w\<ֈrx lGp.w{[Qp( CFV]w{+iU\mj:}؊X%b#uflG~mc;,w]wh%ζH9%6{ ; ;9f^ o}C] 0k[]@[*]̕~5V}/^p/ӹIRė2gukC%@<5ԝQ7G ]2-*loOk]6EPK E )index.jsUTWSux PKNM yauzl-3.4.0/test/failure/unexpected EOF.zip000066400000000000000000000003641521126516100205550ustar00rootroot00000000000000PK-fH empty.txtPKPK?-fH empty.txtPK,?-S?PKPKyauzl-3.4.0/test/failure/unsupported compression method 1.zip000066400000000000000000000004641521126516100243140ustar00rootroot00000000000000PK KEQVa.txtUT >*S>*Sux asdf PK KEb.txtUT >*S>*Sux bsdf PK KEQVa.txtUT>*Sux PK KEDb.txtUT>*Sux PKyauzl-3.4.0/test/failure/zip64 extended information extra field does not include compressed size.zip000066400000000000000000000003641521126516100334120ustar00rootroot00000000000000PK-c H empty.txtPKPK?-c H empty.txtPK,?-S?PKPKzip64 extended information extra field does not include relative header offset.zip000066400000000000000000000003641521126516100345270ustar00rootroot00000000000000yauzl-3.4.0/test/failurePK-c H empty.txtPKPK?-c H empty.txtPK,?-S?PKPKzip64 extended information extra field does not include uncompressed size.zip000066400000000000000000000003641521126516100336760ustar00rootroot00000000000000yauzl-3.4.0/test/failurePK-c H empty.txtPKPK?-c H empty.txtPK,?-S?PKPKyauzl-3.4.0/test/forAwait.js000066400000000000000000000023021521126516100157500ustar00rootroot00000000000000// Test for this bug: https://github.com/thejoshwolfe/yauzl/issues/169 const yauzl = require("../"); const fs = require("fs"); const path = require("path"); const paths = process.argv.slice(2); if (paths.length === 0) throw new Error("give a path to a zipfile as an arg"); let done = false; yauzl.open(paths[0], {lazyEntries: true}, function(err, zipfile) { if (err) throw err; zipfile.on("error", function(err) { throw err; }); zipfile.once("close", function() { done = true; }); zipfile.readEntry(); zipfile.once("entry", function(entry) { zipfile.openReadStream(entry, function(err, readStream) { if (err) throw err; (async function() { let bytesSeen = 0; console.log("starting..."); for await (let chunk of readStream) { if (bytesSeen === 0) console.log(" ...iterating"); bytesSeen += chunk.length; } console.log("...closing after bytes:", bytesSeen); zipfile.close(); })().catch(function(err) { throw err; }); }); }); }); process.on("exit", function(code) { if (code === 0 && !done) { throw new Error("premature exit. probably means an event never got fired."); } }); yauzl-3.4.0/test/range-test.js000066400000000000000000000145371521126516100162620ustar00rootroot00000000000000var yauzl = require("../"); var PassThrough = require("stream").PassThrough; var util = require("util"); var Pend = require("pend"); var BufferList = require("bl"); exports.runTest = runTest; // zipfile obtained via: // $ echo -n 'aaabaaabaaabaaab' > stored.txt // $ cp stored.txt compressed.txt // $ cp stored.txt encrypted.txt // $ cp stored.txt encrypted-and-compressed.txt // $ rm -f out.zip // $ zip out.zip -0 stored.txt // $ zip out.zip compressed.txt // $ zip out.zip -e0 encrypted.txt // $ zip out.zip -e encrypted-and-compressed.txt var zipfileBuffer = hexToBuffer("" + "504b03040a00000000006a54954ab413389510000000100000000a001c007374" + "6f7265642e7478745554090003d842fa5842c5f75875780b000104e803000004" + "e803000061616162616161626161616261616162504b03041400000008007554" + "954ab413389508000000100000000e001c00636f6d707265737365642e747874" + "5554090003ed42fa58ed42fa5875780b000104e803000004e80300004b4c4c4c" + "4a44c200504b03040a00090000008454954ab41338951c000000100000000d00" + "1c00656e637279707465642e74787455540900030743fa580743fa5875780b00" + "0104e803000004e8030000f72e7bb915142131c934f01b163fcadb2a8db7cdaf" + "d0a6f4dd1694c0504b0708b41338951c00000010000000504b03041400090008" + "008a54954ab413389514000000100000001c001c00656e637279707465642d61" + "6e642d636f6d707265737365642e74787455540900031343fa581343fa587578" + "0b000104e803000004e80300007c4d3ea0d9754b470d3eb32ada5741bfc848f4" + "19504b0708b41338951400000010000000504b01021e030a00000000006a5495" + "4ab413389510000000100000000a0018000000000000000000b4810000000073" + "746f7265642e7478745554050003d842fa5875780b000104e803000004e80300" + "00504b01021e031400000008007554954ab413389508000000100000000e0018" + "000000000001000000b48154000000636f6d707265737365642e747874555405" + "0003ed42fa5875780b000104e803000004e8030000504b01021e030a00090000" + "008454954ab41338951c000000100000000d0018000000000000000000b481a4" + "000000656e637279707465642e74787455540500030743fa5875780b000104e8" + "03000004e8030000504b01021e031400090008008a54954ab413389514000000" + "100000001c0018000000000001000000b48117010000656e637279707465642d" + "616e642d636f6d707265737365642e74787455540500031343fa5875780b0001" + "04e803000004e8030000504b0506000000000400040059010000910100000000" + ""); // the same file in all 4 supported forms: // [0b00]: stored // [0b01]: compressed // [0b10]: encrypted // [0b11]: encrypted and compressed function shouldBeCompressed(index) { return (index & 1) !== 0; } function shouldBeEncrypted (index) { return (index & 2) !== 0; } var expectedFileDatas = [ hexToBuffer("61616162616161626161616261616162"), hexToBuffer("4b4c4c4c4a44c200"), hexToBuffer("f72e7bb915142131c934f01b163fcadb2a8db7cdafd0a6f4dd1694c0"), hexToBuffer("7c4d3ea0d9754b470d3eb32ada5741bfc848f419"), ]; function runTest(cb) { util.inherits(StingyRandomAccessReader, yauzl.RandomAccessReader); function StingyRandomAccessReader(buffer) { yauzl.RandomAccessReader.call(this); this.buffer = buffer; this.upcomingByteCounts = []; } StingyRandomAccessReader.prototype._readStreamForRange = function(start, end) { if (this.upcomingByteCounts.length > 0) { var expectedByteCount = this.upcomingByteCounts.shift(); if (expectedByteCount != null) { if (expectedByteCount !== end - start) { throw new Error("expected " + expectedByteCount + " got " + (end - start) + " bytes"); } } } var result = new PassThrough(); result.write(this.buffer.slice(start, end)); result.end(); return result; }; var zipfileReader = new StingyRandomAccessReader(zipfileBuffer); var options = {lazyEntries: true, autoClose: false}; yauzl.fromRandomAccessReader(zipfileReader, zipfileBuffer.length, options, function(err, zipfile) { var entries = []; zipfile.readEntry(); zipfile.on("entry", function(entry) { var index = entries.length; // asser the structure of the zipfile is what we expect if (entry.isCompressed() !== shouldBeCompressed(index)) throw new Error("assertion failure"); if (entry.isEncrypted() !== shouldBeEncrypted(index)) throw new Error("assertion failure"); entries.push(entry); zipfile.readEntry(); }); zipfile.on("end", function() { // now we get to the testing var pend = new Pend(); // 1 thing at a time for better determinism/reproducibility pend.max = 1; [null, 0, 2].forEach(function(start) { [null, 3, 5].forEach(function(end) { entries.forEach(function(entry, index) { var expectedFileData = expectedFileDatas[index]; pend.go(function(cb) { var effectiveStart = start != null ? start : 0; var effectiveEnd = end != null ? end : expectedFileData.length; var expectedSlice = expectedFileData.slice(effectiveStart, effectiveEnd); // the next read will be to check the local file header. // then we assert that yauzl is asking for just the bytes we asked for. zipfileReader.upcomingByteCounts = [null, expectedSlice.length]; var options = {}; if (start != null) options.start = start; if (end != null) options.end = end; if (entry.isCompressed()) options.decompress = false; if (entry.isEncrypted()) options.decrypt = false; zipfile.openReadStream(entry, options, function(err, readStream) { if (err) throw err; readStream.pipe(BufferList(function(err, data) { var prefix = "openReadStream with range(" + start + "," + end + "," + index + "): "; if (!buffersEqual(data, expectedSlice)) { throw new Error(prefix + "contents mismatch"); } console.log(prefix + "pass"); cb(); })); }); }); }); }); }); pend.wait(cb); }); }); } function hexToBuffer(hexString) { var buffer = Buffer.allocUnsafe(hexString.length / 2); for (var i = 0; i < buffer.length; i++) { buffer[i] = parseInt(hexString.substr(i * 2, 2), 16); } return buffer; } function buffersEqual(a, b) { if (a.length !== b.length) return false; for (var i = 0; i < a.length; i++) { if (a[i] !== b[i]) return false; } return true; } if (require.main === module) runTest(function() {}); yauzl-3.4.0/test/success/000077500000000000000000000000001521126516100153115ustar00rootroot00000000000000yauzl-3.4.0/test/success/NtfsTimestamp.zip000066400000000000000000000002541521126516100206340ustar00rootroot00000000000000PK- C*$a 0H”PK?- C*$a 0H”PKSCyauzl-3.4.0/test/success/NtfsTimestamp/000077500000000000000000000000001521126516100201075ustar00rootroot00000000000000yauzl-3.4.0/test/success/NtfsTimestamp/a000066400000000000000000000000001521126516100202400ustar00rootroot00000000000000yauzl-3.4.0/test/success/big-compression.zip000066400000000000000000000004671521126516100211440ustar00rootroot00000000000000PKH\P0x21000UT QjQjux d nH@/PKH\P0x21000UTQjux dPKMyauzl-3.4.0/test/success/big-compression/000077500000000000000000000000001521126516100204115ustar00rootroot00000000000000yauzl-3.4.0/test/success/big-compression/0x21000000066400000000000000000004100001521126516100212410ustar00rootroot00000000000000yauzl-3.4.0/test/success/big-uncompressed.zip000066400000000000000000004102441521126516100213100ustar00rootroot00000000000000PK F\P0x21000UT jjux dPK F\P0x21000UTjux dPKMAyauzl-3.4.0/test/success/big-uncompressed/000077500000000000000000000000001521126516100205575ustar00rootroot00000000000000yauzl-3.4.0/test/success/big-uncompressed/0x21000000066400000000000000000004100001521126516100214070ustar00rootroot00000000000000yauzl-3.4.0/test/success/bogus-compression-method.zip000066400000000000000000000056611521126516100230010ustar00rootroot00000000000000PK E )index.jsUT WSWSux Z[o~C#ۺUov\IZ" $Ų69s 9dj 9sΙ܇z 5+p>%,MJ..H YU A%򑆼rIsEg4`˶}4HH<Z"K ۪.ء t;Cd MzE@LQOK%Q¬72I%֎ir: ҲU(d~ ,Q=漨J5#~ ?ڍI$&4OoI2"8V=&RAq8 ,64CyX>aK*63ْf~SXlC*< {4(8 A}PD%\ RFJCj/$\M"11 =+I@ ͱ`IBmIS@=SEG4",PQc߱pG ^ A{ zsDV\ncF 4PVDY xaӫ,YJtö5Kt^CRZQP`>iб"Aۃxu6TpPi$bVUN8{4eDe"qda^ J OhX U< ~xHentaS1-;HӔ;o P11Eu)0螼 ABV<-wa~y,SlldfƱ'i0^0D]hg5(srC헬Z.وqv9q +DIŲ6ɤ{qx&0ϰ9aC{km"@(Zkkno_uA&Y([5ZYg@]?؍HcCtpBgbqHuŅFD*2[bȲ]ziƇ\9twg, tq2J>J5}Ê aei ^%]6f" [V*)^ pjUcd(y8l߉-7Iyb"V,{$x#$ +}U?(zJsˮx;Y.l pe&{ J [rNeaf*{X5sFK1fK8 op(㥅xR~i+ܞe-?ZP9$cHN,h *H1&GK HP߿>U,Y^IN  B?Y6(%LEڿ뗸ZR Y]*_y~\W(nvة,< ױL'(sW+U|5 0e݇k$O\ŕ7u3KBt8LZ脅<{*MHl 37WXXXԷ/rY_;8ݼ-3@6CFQDVe嵳I ߾*޼mVp77ṑإ} mMmI)(ıV6 &]`sdvmi۬=Y:3m&)וV}Dͭu'Gӝٗt= }sgscFN=Z2@ޝW8ނ .:|G?YySvmX͖-w\a (: Фfz=ݜCN+fУ5࣫_(w\<ֈrx lGp.w{[Qp( CFV]w{+iU\mj:}؊X%b#uflG~mc;,w]wh%ζH9%6{ ; ;9f^ o}C] 0k[]@[*]̕~5V}/^p/ӹIRė2gukC%@<5ԝQ7G ]2-*loOk]6EPK E )index.jsUTWSux PKNM yauzl-3.4.0/test/success/bogus-compression-method/000077500000000000000000000000001521126516100222455ustar00rootroot00000000000000yauzl-3.4.0/test/success/bogus-compression-method/index.js000066400000000000000000000054131521126516100237150ustar00rootroot00000000000000Z[o~C#ۺUov\IZ" $Ų69s 9dj 9sΙ܇z 5+p>%,MJ..H YU A%򑆼rIsEg4`˶}4HH<Z"K ۪.ء t;Cd MzE@LQOK%Q¬72I%֎ir: ҲU(d~ ,Q=漨J5#~ ?ڍI$&4OoI2"8V=&RAq8 ,64CyX>aK*63ْf~SXlC*< {4(8 A}PD%\ RFJCj/$\M"11 =+I@ ͱ`IBmIS@=SEG4",PQc߱pG ^ A{ zsDV\ncF 4PVDY xaӫ,YJtö5Kt^CRZQP`>iб"Aۃxu6TpPi$bVUN8{4eDe"qda^ J OhX U< ~xHentaS1-;HӔ;o P11Eu)0螼 ABV<-wa~y,SlldfƱ'i0^0D]hg5(srC헬Z.وqv9q +DIŲ6ɤ{qx&0ϰ9aC{km"@(Zkkno_uA&Y([5ZYg@]?؍HcCtpBgbqHuŅFD*2[bȲ]ziƇ\9twg, tq2J>J5}Ê aei ^%]6f" [V*)^ pjUcd(y8l߉-7Iyb"V,{$x#$ +}U?(zJsˮx;Y.l pe&{ J [rNeaf*{X5sFK1fK8 op(㥅xR~i+ܞe-?ZP9$cHN,h *H1&GK HP߿>U,Y^IN  B?Y6(%LEڿ뗸ZR Y]*_y~\W(nvة,< ױL'(sW+U|5 0e݇k$O\ŕ7u3KBt8LZ脅<{*MHl 37WXXXԷ/rY_;8ݼ-3@6CFQDVe嵳I ߾*޼mVp77ṑإ} mMmI)(ıV6 &]`sdvmi۬=Y:3m&)וV}Dͭu'Gӝٗt= }sgscFN=Z2@ޝW8ނ .:|G?YySvmX͖-w\a (: Фfz=ݜCN+fУ5࣫_(w\<ֈrx lGp.w{[Qp( CFV]w{+iU\mj:}؊X%b#uflG~mc;,w]wh%ζH9%6{ ; ;9f^ o}C] 0k[]@[*]̕~5V}/^p/ӹIRė2gukC%@<5ԝQ7G ]2-*loOk]6Eyauzl-3.4.0/test/success/cygwin-info-zip.zip000066400000000000000000000004641521126516100210720ustar00rootroot00000000000000PK KEQVa.txtUT =*S=*Sux +z+asdf PK KEb.txtUT =*S=*Sux +z+bsdf PK KEQVa.txtUT=*Sux +z+PK KEDb.txtUT=*Sux +z+PKyauzl-3.4.0/test/success/cygwin-info-zip/000077500000000000000000000000001521126516100203425ustar00rootroot00000000000000yauzl-3.4.0/test/success/cygwin-info-zip/a.txt000066400000000000000000000000051521126516100213160ustar00rootroot00000000000000asdf yauzl-3.4.0/test/success/cygwin-info-zip/b.txt000066400000000000000000000000051521126516100213170ustar00rootroot00000000000000bsdf yauzl-3.4.0/test/success/deflate.zip000066400000000000000000000056611521126516100174510ustar00rootroot00000000000000PK E )index.jsUT WSWSux Z[o~C#ۺUov\IZ" $Ų69s 9dj 9sΙ܇z 5+p>%,MJ..H YU A%򑆼rIsEg4`˶}4HH<Z"K ۪.ء t;Cd MzE@LQOK%Q¬72I%֎ir: ҲU(d~ ,Q=漨J5#~ ?ڍI$&4OoI2"8V=&RAq8 ,64CyX>aK*63ْf~SXlC*< {4(8 A}PD%\ RFJCj/$\M"11 =+I@ ͱ`IBmIS@=SEG4",PQc߱pG ^ A{ zsDV\ncF 4PVDY xaӫ,YJtö5Kt^CRZQP`>iб"Aۃxu6TpPi$bVUN8{4eDe"qda^ J OhX U< ~xHentaS1-;HӔ;o P11Eu)0螼 ABV<-wa~y,SlldfƱ'i0^0D]hg5(srC헬Z.وqv9q +DIŲ6ɤ{qx&0ϰ9aC{km"@(Zkkno_uA&Y([5ZYg@]?؍HcCtpBgbqHuŅFD*2[bȲ]ziƇ\9twg, tq2J>J5}Ê aei ^%]6f" [V*)^ pjUcd(y8l߉-7Iyb"V,{$x#$ +}U?(zJsˮx;Y.l pe&{ J [rNeaf*{X5sFK1fK8 op(㥅xR~i+ܞe-?ZP9$cHN,h *H1&GK HP߿>U,Y^IN  B?Y6(%LEڿ뗸ZR Y]*_y~\W(nvة,< ױL'(sW+U|5 0e݇k$O\ŕ7u3KBt8LZ脅<{*MHl 37WXXXԷ/rY_;8ݼ-3@6CFQDVe嵳I ߾*޼mVp77ṑإ} mMmI)(ıV6 &]`sdvmi۬=Y:3m&)וV}Dͭu'Gӝٗt= }sgscFN=Z2@ޝW8ނ .:|G?YySvmX͖-w\a (: Фfz=ݜCN+fУ5࣫_(w\<ֈrx lGp.w{[Qp( CFV]w{+iU\mj:}؊X%b#uflG~mc;,w]wh%ζH9%6{ ; ;9f^ o}C] 0k[]@[*]̕~5V}/^p/ӹIRė2gukC%@<5ԝQ7G ]2-*loOk]6EPK E )index.jsUTWSux PKNM yauzl-3.4.0/test/success/deflate/000077500000000000000000000000001521126516100167155ustar00rootroot00000000000000yauzl-3.4.0/test/success/deflate/index.js000066400000000000000000000247011521126516100203660ustar00rootroot00000000000000var fs = require("fs"); var FdSlicer = require("fd-slicer"); // cd - Central Directory // cdr - Central Directory Record // eocdr - End of Central Directory Record open("test/cygwin-info-zip.zip", function(err, zipfile) { if (err) throw err; console.log("entries:", zipfile.entriesRemaining()); keepReading(); function keepReading() { if (zipfile.entriesRemaining() === 0) return; zipfile.readEntry(function(err, entry) { if (err) throw err; console.log(entry); zipfile.openReadStream(entry, function(err, readStream) { if (err) throw err; readStream.pipe(process.stdout); }); keepReading(); }); } }); module.exports.open = open; function open(path, callback) { if (callback == null) callback = defaultCallback; fs.open(path, "r", function(err, fd) { if (err) return callback(err); fopen(fd, function(err, zipfile) { if (err) fs.close(fd, defaultCallback); callback(err, zipfile); }); }); } module.exports.fopen = fopen; function fopen(fd, callback) { if (callback == null) callback = defaultCallback; fs.fstat(fd, function(err, stats) { if (err) return callback(err); verbose("searching backwards for the eocdr signature"); // the last field of the eocdr is a variable-length comment. // the comment size is encoded in a 2-byte field in the eocdr, which we can't find without trudging backwards through the comment to find it. // as a consequence of this design decision, it's possible to have ambiguous zip file metadata if, for example, a coherent eocdr was in the comment. // we search backwards for the first eocdr signature, and hope that whoever made the zip file was smart enough to forbid the eocdr signature in the comment. var eocdrWithoutCommentSize = 22; var maxCommentSize = 0x10000; // 2-byte size var bufferSize = Math.min(eocdrWithoutCommentSize + maxCommentSize, stats.size); var buffer = new Buffer(bufferSize); var bufferReadStart = stats.size - buffer.length; readNoEof(fd, buffer, 0, bufferSize, bufferReadStart, function(err) { if (err) return callback(err); for (var i = bufferSize - eocdrWithoutCommentSize; i >= 0; i -= 1) { if (buffer.readUInt32LE(i) !== 0x06054b50) continue; verbose("found eocdr at offset: " + (bufferReadStart + i)); var eocdrBuffer = buffer.slice(i); // 0 - End of central directory signature = 0x06054b50 // 4 - Number of this disk var diskNumber = eocdrBuffer.readUInt16LE(4); if (diskNumber !== 0) return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber)); // 6 - Disk where central directory starts // 8 - Number of central directory records on this disk // 10 - Total number of central directory records var entryCount = eocdrBuffer.readUInt16LE(10); // 12 - Size of central directory (bytes) // 16 - Offset of start of central directory, relative to start of archive var cdOffset = eocdrBuffer.readUInt32LE(16); // 20 - Comment length var commentLength = eocdrBuffer.readUInt16LE(20); var expectedCommentLength = eocdrBuffer.length - eocdrWithoutCommentSize; if (commentLength !== expectedCommentLength) { return callback(new Error("invalid comment length. expected: " + expectedCommentLength + ". found: " + commentLength)); } // 22 - Comment var comment = new Buffer(commentLength); // the comment length is typcially 0. // copy from the original buffer to make sure we're not pinning it from being GC'ed. eocdrBuffer.copy(comment, 0, 22, eocdrBuffer.length); return callback(null, new ZipFile(fd, cdOffset, entryCount, comment)); } callback(new Error("end of central directory record signature not found")); }); }); } function ZipFile(fd, cdOffset, entryCount, comment) { this.fdSlicer = new FdSlicer(fd); this.readEntryCursor = cdOffset; this.entryCount = entryCount; this.comment = comment; this.entriesRead = 0; this.isReadingEntry = false; } ZipFile.prototype.close = function(callback) { if (callback == null) callback = defaultCallback; fs.close(this.fdSlicer.fd, callback); }; ZipFile.prototype.readEntries = function(callback) { var self = this; if (callback == null) callback = defaultCallback; var entries = []; keepReading(); function keepReading() { self.readEntry(function(err, entry) { if (err) return callback(err); entries.push(entry); if (self.entriesRemaining() > 0) { keepReading(); } else { callback(null, entries); } }); } }; ZipFile.prototype.entriesRemaining = function() { return this.entryCount - this.entriesRead; }; ZipFile.prototype.readEntry = function(callback) { var self = this; if (self.isReadingEntry) throw new Error("readEntry already in progress"); self.isReadingEntry = true; if (callback == null) callback = defaultCallback; var buffer = new Buffer(46); readFdSlicerNoEof(this.fdSlicer, buffer, 0, buffer.length, this.readEntryCursor, function(err) { if (err) return callback(err); var entry = {}; // 0 - Central directory file header signature var signature = buffer.readUInt32LE(0); if (signature !== 0x02014b50) return callback(new Error("invalid central directory file header signature: 0x" + signature.toString(16))); // 4 - Version made by entry.versionMadeBy = buffer.readUInt16LE(4); // 6 - Version needed to extract (minimum) entry.versionNeededToExtract = buffer.readUInt16LE(6); // 8 - General purpose bit flag entry.generalPurposeBitFlag = buffer.readUInt16LE(8); // 10 - Compression method entry.compressionMethod = buffer.readUInt16LE(10); // 12 - File last modification time entry.lastModFileTime = buffer.readUInt16LE(12); // 14 - File last modification date entry.lastModFileDate = buffer.readUInt16LE(14); // 16 - CRC-32 entry.crc32 = buffer.readUInt32LE(16); // 20 - Compressed size entry.compressedSize = buffer.readUInt32LE(20); // 24 - Uncompressed size entry.uncompressedSize = buffer.readUInt32LE(24); // 28 - File name length (n) entry.fileNameLength = buffer.readUInt16LE(28); // 30 - Extra field length (m) entry.extraFieldLength = buffer.readUInt16LE(30); // 32 - File comment length (k) entry.fileCommentLength = buffer.readUInt16LE(32); // 34 - Disk number where file starts // 36 - Internal file attributes entry.internalFileAttributes = buffer.readUInt16LE(36); // 38 - External file attributes entry.externalFileAttributes = buffer.readUInt32LE(38); // 42 - Relative offset of local file header entry.relativeOffsetOfLocalHeader = buffer.readUInt32LE(42); self.readEntryCursor += 46; buffer = new Buffer(entry.fileNameLength + entry.extraFieldLength + entry.fileCommentLength); readFdSlicerNoEof(self.fdSlicer, buffer, 0, buffer.length, self.readEntryCursor, function(err) { if (err) return callback(err); // 46 - File name var encoding = entry.generalPurposeBitFlag & 0x800 ? "utf8" : "ascii"; // TODO: replace ascii with CP437 using https://github.com/bnoordhuis/node-iconv entry.fileName = buffer.toString(encoding, 0, entry.fileNameLength); // 46+n - Extra field var fileCommentStart = entry.fileNameLength + entry.extraFieldLength; var extraFieldBuffer = buffer.slice(entry.fileNameLength, fileCommentStart); entry.extraFields = []; var i = 0; while (i < extraFieldBuffer.length) { var headerId = extraFieldBuffer.readUInt16LE(i + 0); var dataSize = extraFieldBuffer.readUInt16LE(i + 2); var dataStart = i + 4; var dataEnd = dataStart + dataSize; var dataBuffer = new Buffer(dataSize); extraFieldBuffer.copy(dataBuffer, 0, dataStart, dataEnd); entry.extraFields.push({ id: headerId, data: dataBuffer, }); i = dataEnd; } // 46+n+m - File comment entry.fileComment = buffer.toString(encoding, fileCommentStart, fileCommentStart + entry.fileCommentLength); self.readEntryCursor += buffer.length; self.entriesRead += 1; self.isReadingEntry = false; callback(null, entry); }); }); }; ZipFile.prototype.openReadStream = function(entry, callback) { var self = this; var buffer = new Buffer(30); readFdSlicerNoEof(self.fdSlicer, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader, function(err) { if (err) return callback(err); // 0 - Local file header signature = 0x04034b50 var signature = buffer.readUInt32LE(0); if (signature !== 0x04034b50) callback(new Error("invalid local file header signature: 0x" + signature.toString(16))); // all this should be redundant // 4 - Version needed to extract (minimum) // 6 - General purpose bit flag // 8 - Compression method // 10 - File last modification time // 12 - File last modification date // 14 - CRC-32 // 18 - Compressed size // 22 - Uncompressed size // 26 - File name length (n) var fileNameLength = buffer.readUInt16LE(26); // 28 - Extra field length (m) var extraFieldLength = buffer.readUInt16LE(28); // 30 - File name // 30+n - Extra field var localFileHeaderEnd = entry.relativeOffsetOfLocalHeader + buffer.length + fileNameLength + extraFieldLength; if (entry.compressionMethod === 0) { // 0 - The file is stored (no compression) } else { return callback(new Error("unsupported compression method: " + entry.compressionMethod)); } var fileDataStart = localFileHeaderEnd; var fileDataEnd = fileDataStart + entry.compressedSize; var readStream = self.fdSlicer.createReadStream({start: fileDataStart, end: fileDataEnd}); callback(null, readStream); }); }; function verbose(message) { console.log(message); } function readNoEof(fd, buffer, offset, length, position, callback) { fs.read(fd, buffer, offset, length, position, function(err, bytesRead) { if (err) return callback(err); if (bytesRead < length) return callback(new Error("unexpected EOF")); callback(null, buffer); }); } function readFdSlicerNoEof(fdSlicer, buffer, offset, length, position, callback) { fdSlicer.read(buffer, offset, length, position, function(err, bytesRead) { if (err) return callback(err); if (bytesRead < length) return callback(new Error("unexpected EOF")); callback(null, buffer); }); } function defaultCallback(err) { if (err) throw err; } yauzl-3.4.0/test/success/directories.zip000066400000000000000000000006541521126516100203560ustar00rootroot00000000000000PK Ea/UT SSux PK Ea/a.txtUT SSux PK Eb/UT 3S3Sux PK EAa/UTSux PK E<a/a.txtUTSux PK EA}b/UT3Sux PKyauzl-3.4.0/test/success/directories/000077500000000000000000000000001521126516100176255ustar00rootroot00000000000000yauzl-3.4.0/test/success/directories/a/000077500000000000000000000000001521126516100200455ustar00rootroot00000000000000yauzl-3.4.0/test/success/directories/a/a.txt000066400000000000000000000000001521126516100210140ustar00rootroot00000000000000yauzl-3.4.0/test/success/directories/b/000077500000000000000000000000001521126516100200465ustar00rootroot00000000000000yauzl-3.4.0/test/success/directories/b/.git_please_make_this_directory000066400000000000000000000000001521126516100262610ustar00rootroot00000000000000yauzl-3.4.0/test/success/empty.zip000066400000000000000000000000261521126516100171710ustar00rootroot00000000000000PKyauzl-3.4.0/test/success/empty/000077500000000000000000000000001521126516100164475ustar00rootroot00000000000000yauzl-3.4.0/test/success/empty/.git_please_make_this_directory000066400000000000000000000000001521126516100246620ustar00rootroot00000000000000yauzl-3.4.0/test/success/everything.zip000066400000000000000000010374671521126516100202430ustar00rootroot00000000000000PK ]\P0x21000UT (j>jux dPK ]\a/UT ujjux dPK ]\Oa/longlonglonglonglonglonglonglonglonglonglonglonglonglonglongkindalongname.txtUT ujjux dPK ^\a/b/UT jjux dPK ]\a/b/c/UT >jjux dPK]\P a/b/c/0x21000UT >jjux d nH@/PK ^\a/b/000UT jjux dPK ^\a/b/001UT jjux dPK ^\a/b/002UT jjux dPK ^\a/b/003UT jjux dPK ^\a/b/004UT jjux dPK ^\a/b/005UT jjux dPK ^\a/b/006UT jjux dPK ^\a/b/007UT jjux dPK ^\a/b/008UT jjux dPK ^\a/b/009UT jjux dPK ^\a/b/010UT jjux dPK ^\a/b/011UT jjux dPK ^\a/b/012UT jjux dPK ^\a/b/013UT jjux dPK ^\a/b/014UT jjux dPK ^\a/b/015UT jjux dPK ^\a/b/016UT jjux dPK ^\a/b/017UT jjux dPK ^\a/b/018UT jjux dPK ^\a/b/019UT jjux dPK ^\a/b/020UT jjux dPK ^\a/b/021UT jjux dPK ^\a/b/022UT jjux dPK ^\a/b/023UT jjux dPK ^\a/b/024UT jjux dPK ^\a/b/025UT jjux dPK ^\a/b/026UT jjux dPK ^\a/b/027UT jjux dPK ^\a/b/028UT jjux dPK ^\a/b/029UT jjux dPK ^\a/b/030UT jjux dPK ^\a/b/031UT jjux dPK ^\a/b/032UT jjux dPK ^\a/b/033UT jjux dPK ^\a/b/034UT jjux dPK ^\a/b/035UT jjux dPK ^\a/b/036UT jjux dPK ^\a/b/037UT jjux dPK ^\a/b/038UT jjux dPK ^\a/b/039UT jjux dPK ^\a/b/040UT jjux dPK ^\a/b/041UT jjux dPK ^\a/b/042UT jjux dPK ^\a/b/043UT jjux dPK ^\a/b/044UT jjux dPK ^\a/b/045UT jjux dPK ^\a/b/046UT jjux dPK ^\a/b/047UT jjux dPK ^\a/b/048UT jjux dPK ^\a/b/049UT jjux dPK ^\a/b/050UT jjux dPK ^\a/b/051UT jjux dPK ^\a/b/052UT jjux dPK ^\a/b/053UT jjux dPK ^\a/b/054UT jjux dPK ^\a/b/055UT jjux dPK ^\a/b/056UT jjux dPK ^\a/b/057UT jjux dPK ^\a/b/058UT jjux dPK ^\a/b/059UT jjux dPK ^\a/b/060UT jjux dPK ^\a/b/061UT jjux dPK ^\a/b/062UT jjux dPK ^\a/b/063UT jjux dPK ^\a/b/064UT jjux dPK ^\a/b/065UT jjux dPK ^\a/b/066UT jjux dPK ^\a/b/067UT jjux dPK ^\a/b/068UT jjux dPK ^\a/b/069UT jjux dPK ^\a/b/070UT jjux dPK ^\a/b/071UT jjux dPK ^\a/b/072UT jjux dPK ^\a/b/073UT jjux dPK ^\a/b/074UT jjux dPK ^\a/b/075UT jjux dPK ^\a/b/076UT jjux dPK ^\a/b/077UT jjux dPK ^\a/b/078UT jjux dPK ^\a/b/079UT jjux dPK ^\a/b/080UT jjux dPK ^\a/b/081UT jjux dPK ^\a/b/082UT jjux dPK ^\a/b/083UT jjux dPK ^\a/b/084UT jjux dPK ^\a/b/085UT jjux dPK ^\a/b/086UT jjux dPK ^\a/b/087UT jjux dPK ^\a/b/088UT jjux dPK ^\a/b/089UT jjux dPK ^\a/b/090UT jjux dPK ^\a/b/091UT jjux dPK ^\a/b/092UT jjux dPK ^\a/b/093UT jjux dPK ^\a/b/094UT jjux dPK ^\a/b/095UT jjux dPK ^\a/b/096UT jjux dPK ^\a/b/097UT jjux dPK ^\a/b/098UT jjux dPK ^\a/b/099UT jjux dPK ^\a/b/100UT jjux dPK ^\a/b/101UT jjux dPK ^\a/b/102UT jjux dPK ^\a/b/103UT jjux dPK ^\a/b/104UT jjux dPK ^\a/b/105UT jjux dPK ^\a/b/106UT jjux dPK ^\a/b/107UT jjux dPK ^\a/b/108UT jjux dPK ^\a/b/109UT jjux dPK ^\a/b/110UT jjux dPK ^\a/b/111UT jjux dPK ^\a/b/112UT jjux dPK ^\a/b/113UT jjux dPK ^\a/b/114UT jjux dPK ^\a/b/115UT jjux dPK ^\a/b/116UT jjux dPK ^\a/b/117UT jjux dPK ^\a/b/118UT jjux dPK ^\a/b/119UT jjux dPK ^\a/b/120UT jjux dPK ^\a/b/121UT jjux dPK ^\a/b/122UT jjux dPK ^\a/b/123UT jjux dPK ^\a/b/124UT jjux dPK ^\a/b/125UT jjux dPK ^\a/b/126UT jjux dPK ^\a/b/127UT jjux dPK ^\a/b/128UT jjux dPK ^\a/b/129UT jjux dPK ^\a/b/130UT jjux dPK ^\a/b/131UT jjux dPK ^\a/b/132UT jjux dPK ^\a/b/133UT jjux dPK ^\a/b/134UT jjux dPK ^\a/b/135UT jjux dPK ^\a/b/136UT jjux dPK ^\a/b/137UT jjux dPK ^\a/b/138UT jjux dPK ^\a/b/139UT jjux dPK ^\a/b/140UT jjux dPK ^\a/b/141UT jjux dPK ^\a/b/142UT jjux dPK ^\a/b/143UT jjux dPK ^\a/b/144UT jjux dPK ^\a/b/145UT jjux dPK ^\a/b/146UT jjux dPK ^\a/b/147UT jjux dPK ^\a/b/148UT jjux dPK ^\a/b/149UT jjux dPK ^\a/b/150UT jjux dPK ^\a/b/151UT jjux dPK ^\a/b/152UT jjux dPK ^\a/b/153UT jjux dPK ^\a/b/154UT jjux dPK ^\a/b/155UT jjux dPK ^\a/b/156UT jjux dPK ^\a/b/157UT jjux dPK ^\a/b/158UT jjux dPK ^\a/b/159UT jjux dPK ^\a/b/160UT jjux dPK ^\a/b/161UT jjux dPK ^\a/b/162UT jjux dPK ^\a/b/163UT jjux dPK ^\a/b/164UT jjux dPK ^\a/b/165UT jjux dPK ^\a/b/166UT jjux dPK ^\a/b/167UT jjux dPK ^\a/b/168UT jjux dPK ^\a/b/169UT jjux dPK ^\a/b/170UT jjux dPK ^\a/b/171UT jjux dPK ^\a/b/172UT jjux dPK ^\a/b/173UT jjux dPK ^\a/b/174UT jjux dPK ^\a/b/175UT jjux dPK ^\a/b/176UT jjux dPK ^\a/b/177UT jjux dPK ^\a/b/178UT jjux dPK ^\a/b/179UT jjux dPK ^\a/b/180UT jjux dPK ^\a/b/181UT jjux dPK ^\a/b/182UT jjux dPK ^\a/b/183UT jjux dPK ^\a/b/184UT jjux dPK ^\a/b/185UT jjux dPK ^\a/b/186UT jjux dPK ^\a/b/187UT jjux dPK ^\a/b/188UT jjux dPK ^\a/b/189UT jjux dPK ^\a/b/190UT jjux dPK ^\a/b/191UT jjux dPK ^\a/b/192UT jjux dPK ^\a/b/193UT jjux dPK ^\a/b/194UT jjux dPK ^\a/b/195UT jjux dPK ^\a/b/196UT jjux dPK ^\a/b/197UT jjux dPK ^\a/b/198UT jjux dPK ^\a/b/199UT jjux dPK ^\a/b/200UT jjux dPK ^\a/b/201UT jjux dPK ^\a/b/202UT jjux dPK ^\a/b/203UT jjux dPK ^\a/b/204UT jjux dPK ^\a/b/205UT jjux dPK ^\a/b/206UT jjux dPK ^\a/b/207UT jjux dPK ^\a/b/208UT jjux dPK ^\a/b/209UT jjux dPK ^\a/b/210UT jjux dPK ^\a/b/211UT jjux dPK ^\a/b/212UT jjux dPK ^\a/b/213UT jjux dPK ^\a/b/214UT jjux dPK ^\a/b/215UT jjux dPK ^\a/b/216UT jjux dPK ^\a/b/217UT jjux dPK ^\a/b/218UT jjux dPK ^\a/b/219UT jjux dPK ^\a/b/220UT jjux dPK ^\a/b/221UT jjux dPK ^\a/b/222UT jjux dPK ^\a/b/223UT jjux dPK ^\a/b/224UT jjux dPK ^\a/b/225UT jjux dPK ^\a/b/226UT jjux dPK ^\a/b/227UT jjux dPK ^\a/b/228UT jjux dPK ^\a/b/229UT jjux dPK ^\a/b/230UT jjux dPK ^\a/b/231UT jjux dPK ^\a/b/232UT jjux dPK ^\a/b/233UT jjux dPK ^\a/b/234UT jjux dPK ^\a/b/235UT jjux dPK ^\a/b/236UT jjux dPK ^\a/b/237UT jjux dPK ^\a/b/238UT jjux dPK ^\a/b/239UT jjux dPK ^\a/b/240UT jjux dPK ^\a/b/241UT jjux dPK ^\a/b/242UT jjux dPK ^\a/b/243UT jjux dPK ^\a/b/244UT jjux dPK ^\a/b/245UT jjux dPK ^\a/b/246UT jjux dPK ^\a/b/247UT jjux dPK ^\a/b/248UT jjux dPK ^\a/b/249UT jjux dPK ^\a/b/250UT jjux dPK ^\a/b/251UT jjux dPK ^\a/b/252UT jjux dPK ^\a/b/253UT jjux dPK ^\a/b/254UT jjux dPK ^\a/b/255UT jjux dPK ^\a/b/256UT jjux dPK ^\a/b/257UT jjux dPK ^\a/b/258UT jjux dPK ^\a/b/259UT jjux dPK ^\a/b/260UT jjux dPK ^\a/b/261UT jjux dPK ^\a/b/262UT jjux dPK ^\a/b/263UT jjux dPK ^\a/b/264UT jjux dPK ^\a/b/265UT jjux dPK ^\a/b/266UT jjux dPK ^\a/b/267UT jjux dPK ^\a/b/268UT jjux dPK ^\a/b/269UT jjux dPK ^\a/b/270UT jjux dPK ^\a/b/271UT jjux dPK ^\a/b/272UT jjux dPK ^\a/b/273UT jjux dPK ^\a/b/274UT jjux dPK ^\a/b/275UT jjux dPK ^\a/b/276UT jjux dPK ^\a/b/277UT jjux dPK ^\a/b/278UT jjux dPK ^\a/b/279UT jjux dPK ^\a/b/280UT jjux dPK ^\a/b/281UT jjux dPK ^\a/b/282UT jjux dPK ^\a/b/283UT jjux dPK ^\a/b/284UT jjux dPK ^\a/b/285UT jjux dPK ^\a/b/286UT jjux dPK ^\a/b/287UT jjux dPK ^\a/b/288UT jjux dPK ^\a/b/289UT jjux dPK ^\a/b/290UT jjux dPK ^\a/b/291UT jjux dPK ^\a/b/292UT jjux dPK ^\a/b/293UT jjux dPK ^\a/b/294UT jjux dPK ^\a/b/295UT jjux dPK ^\a/b/296UT jjux dPK ^\a/b/297UT jjux dPK ^\a/b/298UT jjux dPK ^\a/b/299UT jjux dPK ^\a/b/300UT jjux dPK ^\a/b/301UT jjux dPK ^\a/b/302UT jjux dPK ^\a/b/303UT jjux dPK ^\a/b/304UT jjux dPK ^\a/b/305UT jjux dPK ^\a/b/306UT jjux dPK ^\a/b/307UT jjux dPK ^\a/b/308UT jjux dPK ^\a/b/309UT jjux dPK ^\a/b/310UT jjux dPK ^\a/b/311UT jjux dPK ^\a/b/312UT jjux dPK ^\a/b/313UT jjux dPK ^\a/b/314UT jjux dPK ^\a/b/315UT jjux dPK ^\a/b/316UT jjux dPK ^\a/b/317UT jjux dPK ^\a/b/318UT jjux dPK ^\a/b/319UT jjux dPK ^\a/b/320UT jjux dPK ^\a/b/321UT jjux dPK ^\a/b/322UT jjux dPK ^\a/b/323UT jjux dPK ^\a/b/324UT jjux dPK ^\a/b/325UT jjux dPK ^\a/b/326UT jjux dPK ^\a/b/327UT jjux dPK ^\a/b/328UT jjux dPK ^\a/b/329UT jjux dPK ^\a/b/330UT jjux dPK ^\a/b/331UT jjux dPK ^\a/b/332UT jjux dPK ^\a/b/333UT jjux dPK ^\a/b/334UT jjux dPK ^\a/b/335UT jjux dPK ^\a/b/336UT jjux dPK ^\a/b/337UT jjux dPK ^\a/b/338UT jjux dPK ^\a/b/339UT jjux dPK ^\a/b/340UT jjux dPK ^\a/b/341UT jjux dPK ^\a/b/342UT jjux dPK ^\a/b/343UT jjux dPK ^\a/b/344UT jjux dPK ^\a/b/345UT jjux dPK ^\a/b/346UT jjux dPK ^\a/b/347UT jjux dPK ^\a/b/348UT jjux dPK ^\a/b/349UT jjux dPK ^\a/b/350UT jjux dPK ^\a/b/351UT jjux dPK ^\a/b/352UT jjux dPK ^\a/b/353UT jjux dPK ^\a/b/354UT jjux dPK ^\a/b/355UT jjux dPK ^\a/b/356UT jjux dPK ^\a/b/357UT jjux dPK ^\a/b/358UT jjux dPK ^\a/b/359UT jjux dPK ^\a/b/360UT jjux dPK ^\a/b/361UT jjux dPK ^\a/b/362UT jjux dPK ^\a/b/363UT jjux dPK ^\a/b/364UT jjux dPK ^\a/b/365UT jjux dPK ^\a/b/366UT jjux dPK ^\a/b/367UT jjux dPK ^\a/b/368UT jjux dPK ^\a/b/369UT jjux dPK ^\a/b/370UT jjux dPK ^\a/b/371UT jjux dPK ^\a/b/372UT jjux dPK ^\a/b/373UT jjux dPK ^\a/b/374UT jjux dPK ^\a/b/375UT jjux dPK ^\a/b/376UT jjux dPK ^\a/b/377UT jjux dPK ^\a/b/378UT jjux dPK ^\a/b/379UT jjux dPK ^\a/b/380UT jjux dPK ^\a/b/381UT jjux dPK ^\a/b/382UT jjux dPK ^\a/b/383UT jjux dPK ^\a/b/384UT jjux dPK ^\a/b/385UT jjux dPK ^\a/b/386UT jjux dPK ^\a/b/387UT jjux dPK ^\a/b/388UT jjux dPK ^\a/b/389UT jjux dPK ^\a/b/390UT jjux dPK ^\a/b/391UT jjux dPK ^\a/b/392UT jjux dPK ^\a/b/393UT jjux dPK ^\a/b/394UT jjux dPK ^\a/b/395UT jjux dPK ^\a/b/396UT jjux dPK ^\a/b/397UT jjux dPK ^\a/b/398UT jjux dPK ^\a/b/399UT jjux dPK ^\a/b/400UT jjux dPK ^\a/b/401UT jjux dPK ^\a/b/402UT jjux dPK ^\a/b/403UT jjux dPK ^\a/b/404UT jjux dPK ^\a/b/405UT jjux dPK ^\a/b/406UT jjux dPK ^\a/b/407UT jjux dPK ^\a/b/408UT jjux dPK ^\a/b/409UT jjux dPK ^\a/b/410UT jjux dPK ^\a/b/411UT jjux dPK ^\a/b/412UT jjux dPK ^\a/b/413UT jjux dPK ^\a/b/414UT jjux dPK ^\a/b/415UT jjux dPK ^\a/b/416UT jjux dPK ^\a/b/417UT jjux dPK ^\a/b/418UT jjux dPK ^\a/b/419UT jjux dPK ^\a/b/420UT jjux dPK ^\a/b/421UT jjux dPK ^\a/b/422UT jjux dPK ^\a/b/423UT jjux dPK ^\a/b/424UT jjux dPK ^\a/b/425UT jjux dPK ^\a/b/426UT jjux dPK ^\a/b/427UT jjux dPK ^\a/b/428UT jjux dPK ^\a/b/429UT jjux dPK ^\a/b/430UT jjux dPK ^\a/b/431UT jjux dPK ^\a/b/432UT jjux dPK ^\a/b/433UT jjux dPK ^\a/b/434UT jjux dPK ^\a/b/435UT jjux dPK ^\a/b/436UT jjux dPK ^\a/b/437UT jjux dPK ^\a/b/438UT jjux dPK ^\a/b/439UT jjux dPK ^\a/b/440UT jjux dPK ^\a/b/441UT jjux dPK ^\a/b/442UT jjux dPK ^\a/b/443UT jjux dPK ^\a/b/444UT jjux dPK ^\a/b/445UT jjux dPK ^\a/b/446UT jjux dPK ^\a/b/447UT jjux dPK ^\a/b/448UT jjux dPK ^\a/b/449UT jjux dPK ^\a/b/450UT jjux dPK ^\a/b/451UT jjux dPK ^\a/b/452UT jjux dPK ^\a/b/453UT jjux dPK ^\a/b/454UT jjux dPK ^\a/b/455UT jjux dPK ^\a/b/456UT jjux dPK ^\a/b/457UT jjux dPK ^\a/b/458UT jjux dPK ^\a/b/459UT jjux dPK ^\a/b/460UT jjux dPK ^\a/b/461UT jjux dPK ^\a/b/462UT jjux dPK ^\a/b/463UT jjux dPK ^\a/b/464UT jjux dPK ^\a/b/465UT jjux dPK ^\a/b/466UT jjux dPK ^\a/b/467UT jjux dPK ^\a/b/468UT jjux dPK ^\a/b/469UT jjux dPK ^\a/b/470UT jjux dPK ^\a/b/471UT jjux dPK ^\a/b/472UT jjux dPK ^\a/b/473UT jjux dPK ^\a/b/474UT jjux dPK ^\a/b/475UT jjux dPK ^\a/b/476UT jjux dPK ^\a/b/477UT jjux dPK ^\a/b/478UT jjux dPK ^\a/b/479UT jjux dPK ^\a/b/480UT jjux dPK ^\a/b/481UT jjux dPK ^\a/b/482UT jjux dPK ^\a/b/483UT jjux dPK ^\a/b/484UT jjux dPK ^\a/b/485UT jjux dPK ^\a/b/486UT jjux dPK ^\a/b/487UT jjux dPK ^\a/b/488UT jjux dPK ^\a/b/489UT jjux dPK ^\a/b/490UT jjux dPK ^\a/b/491UT jjux dPK ^\a/b/492UT jjux dPK ^\a/b/493UT jjux dPK ^\a/b/494UT jjux dPK ^\a/b/495UT jjux dPK ^\a/b/496UT jjux dPK ^\a/b/497UT jjux dPK ^\a/b/498UT jjux dPK ^\a/b/499UT jjux dPK ^\a/b/500UT jjux dPK ^\a/b/501UT jjux dPK ^\a/b/502UT jjux dPK ^\a/b/503UT jjux dPK ^\a/b/504UT jjux dPK ^\a/b/505UT jjux dPK ^\a/b/506UT jjux dPK ^\a/b/507UT jjux dPK ^\a/b/508UT jjux dPK ^\a/b/509UT jjux dPK ^\a/b/510UT jjux dPK ^\a/b/511UT jjux dPK ^\a/b/512UT jjux dPK ^\a/b/513UT jjux dPK ^\a/b/514UT jjux dPK ^\a/b/515UT jjux dPK ^\a/b/516UT jjux dPK ^\a/b/517UT jjux dPK ^\a/b/518UT jjux dPK ^\a/b/519UT jjux dPK ^\a/b/520UT jjux dPK ^\a/b/521UT jjux dPK ^\a/b/522UT jjux dPK ^\a/b/523UT jjux dPK ^\a/b/524UT jjux dPK ^\a/b/525UT jjux dPK ^\a/b/526UT jjux dPK ^\a/b/527UT jjux dPK ^\a/b/528UT jjux dPK ^\a/b/529UT jjux dPK ^\a/b/530UT jjux dPK ^\a/b/531UT jjux dPK ^\a/b/532UT jjux dPK ^\a/b/533UT jjux dPK ^\a/b/534UT jjux dPK ^\a/b/535UT jjux dPK ^\a/b/536UT jjux dPK ^\a/b/537UT jjux dPK ^\a/b/538UT jjux dPK ^\a/b/539UT jjux dPK ^\a/b/540UT jjux dPK ^\a/b/541UT jjux dPK ^\a/b/542UT jjux dPK ^\a/b/543UT jjux dPK ^\a/b/544UT jjux dPK ^\a/b/545UT jjux dPK ^\a/b/546UT jjux dPK ^\a/b/547UT jjux dPK ^\a/b/548UT jjux dPK ^\a/b/549UT jjux dPK ^\a/b/550UT jjux dPK ^\a/b/551UT jjux dPK ^\a/b/552UT jjux dPK ^\a/b/553UT jjux dPK ^\a/b/554UT jjux dPK ^\a/b/555UT jjux dPK ^\a/b/556UT jjux dPK ^\a/b/557UT jjux dPK ^\a/b/558UT jjux dPK ^\a/b/559UT jjux dPK ^\a/b/560UT jjux dPK ^\a/b/561UT jjux dPK ^\a/b/562UT jjux dPK ^\a/b/563UT jjux dPK ^\a/b/564UT jjux dPK ^\a/b/565UT jjux dPK ^\a/b/566UT jjux dPK ^\a/b/567UT jjux dPK ^\a/b/568UT jjux dPK ^\a/b/569UT jjux dPK ^\a/b/570UT jjux dPK ^\a/b/571UT jjux dPK ^\a/b/572UT jjux dPK ^\a/b/573UT jjux dPK ^\a/b/574UT jjux dPK ^\a/b/575UT jjux dPK ^\a/b/576UT jjux dPK ^\a/b/577UT jjux dPK ^\a/b/578UT jjux dPK ^\a/b/579UT jjux dPK ^\a/b/580UT jjux dPK ^\a/b/581UT jjux dPK ^\a/b/582UT jjux dPK ^\a/b/583UT jjux dPK ^\a/b/584UT jjux dPK ^\a/b/585UT jjux dPK ^\a/b/586UT jjux dPK ^\a/b/587UT jjux dPK ^\a/b/588UT jjux dPK ^\a/b/589UT jjux dPK ^\a/b/590UT jjux dPK ^\a/b/591UT jjux dPK ^\a/b/592UT jjux dPK ^\a/b/593UT jjux dPK ^\a/b/594UT jjux dPK ^\a/b/595UT jjux dPK ^\a/b/596UT jjux dPK ^\a/b/597UT jjux dPK ^\a/b/598UT jjux dPK ^\a/b/599UT jjux dPK ^\a/b/600UT jjux dPK ^\a/b/601UT jjux dPK ^\a/b/602UT jjux dPK ^\a/b/603UT jjux dPK ^\a/b/604UT jjux dPK ^\a/b/605UT jjux dPK ^\a/b/606UT jjux dPK ^\a/b/607UT jjux dPK ^\a/b/608UT jjux dPK ^\a/b/609UT jjux dPK ^\a/b/610UT jjux dPK ^\a/b/611UT jjux dPK ^\a/b/612UT jjux dPK ^\a/b/613UT jjux dPK ^\a/b/614UT jjux dPK ^\a/b/615UT jjux dPK ^\a/b/616UT jjux dPK ^\a/b/617UT jjux dPK ^\a/b/618UT jjux dPK ^\a/b/619UT jjux dPK ^\a/b/620UT jjux dPK ^\a/b/621UT jjux dPK ^\a/b/622UT jjux dPK ^\a/b/623UT jjux dPK ^\a/b/624UT jjux dPK ^\a/b/625UT jjux dPK ^\a/b/626UT jjux dPK ^\a/b/627UT jjux dPK ^\a/b/628UT jjux dPK ^\a/b/629UT jjux dPK ^\a/b/630UT jjux dPK ^\a/b/631UT jjux dPK ^\a/b/632UT jjux dPK ^\a/b/633UT jjux dPK ^\a/b/634UT jjux dPK ^\a/b/635UT jjux dPK ^\a/b/636UT jjux dPK ^\a/b/637UT jjux dPK ^\a/b/638UT jjux dPK ^\a/b/639UT jjux dPK ^\a/b/640UT jjux dPK ^\a/b/641UT jjux dPK ^\a/b/642UT jjux dPK ^\a/b/643UT jjux dPK ^\a/b/644UT jjux dPK ^\a/b/645UT jjux dPK ^\a/b/646UT jjux dPK ^\a/b/647UT jjux dPK ^\a/b/648UT jjux dPK ^\a/b/649UT jjux dPK ^\a/b/650UT jjux dPK ^\a/b/651UT jjux dPK ^\a/b/652UT jjux dPK ^\a/b/653UT jjux dPK ^\a/b/654UT jjux dPK ^\a/b/655UT jjux dPK ^\a/b/656UT jjux dPK ^\a/b/657UT jjux dPK ^\a/b/658UT jjux dPK ^\a/b/659UT jjux dPK ^\a/b/660UT jjux dPK ^\a/b/661UT jjux dPK ^\a/b/662UT jjux dPK ^\a/b/663UT jjux dPK ^\a/b/664UT jjux dPK ^\a/b/665UT jjux dPK ^\a/b/666UT jjux dPK ^\a/b/667UT jjux dPK ^\a/b/668UT jjux dPK ^\a/b/669UT jjux dPK ^\a/b/670UT jjux dPK ^\a/b/671UT jjux dPK ^\a/b/672UT jjux dPK ^\a/b/673UT jjux dPK ^\a/b/674UT jjux dPK ^\a/b/675UT jjux dPK ^\a/b/676UT jjux dPK ^\a/b/677UT jjux dPK ^\a/b/678UT jjux dPK ^\a/b/679UT jjux dPK ^\a/b/680UT jjux dPK ^\a/b/681UT jjux dPK ^\a/b/682UT jjux dPK ^\a/b/683UT jjux dPK ^\a/b/684UT jjux dPK ^\a/b/685UT jjux dPK ^\a/b/686UT jjux dPK ^\a/b/687UT jjux dPK ^\a/b/688UT jjux dPK ^\a/b/689UT jjux dPK ^\a/b/690UT jjux dPK ^\a/b/691UT jjux dPK ^\a/b/692UT jjux dPK ^\a/b/693UT jjux dPK ^\a/b/694UT jjux dPK ^\a/b/695UT jjux dPK ^\a/b/696UT jjux dPK ^\a/b/697UT jjux dPK ^\a/b/698UT jjux dPK ^\a/b/699UT jjux dPK ^\a/b/700UT jjux dPK ^\a/b/701UT jjux dPK ^\a/b/702UT jjux dPK ^\a/b/703UT jjux dPK ^\a/b/704UT jjux dPK ^\a/b/705UT jjux dPK ^\a/b/706UT jjux dPK ^\a/b/707UT jjux dPK ^\a/b/708UT jjux dPK ^\a/b/709UT jjux dPK ^\a/b/710UT jjux dPK ^\a/b/711UT jjux dPK ^\a/b/712UT jjux dPK ^\a/b/713UT jjux dPK ^\a/b/714UT jjux dPK ^\a/b/715UT jjux dPK ^\a/b/716UT jjux dPK ^\a/b/717UT jjux dPK ^\a/b/718UT jjux dPK ^\a/b/719UT jjux dPK ^\a/b/720UT jjux dPK ^\a/b/721UT jjux dPK ^\a/b/722UT jjux dPK ^\a/b/723UT jjux dPK ^\a/b/724UT jjux dPK ^\a/b/725UT jjux dPK ^\a/b/726UT jjux dPK ^\a/b/727UT jjux dPK ^\a/b/728UT jjux dPK ^\a/b/729UT jjux dPK ^\a/b/730UT jjux dPK ^\a/b/731UT jjux dPK ^\a/b/732UT jjux dPK ^\a/b/733UT jjux dPK ^\a/b/734UT jjux dPK ^\a/b/735UT jjux dPK ^\a/b/736UT jjux dPK ^\a/b/737UT jjux dPK ^\a/b/738UT jjux dPK ^\a/b/739UT jjux dPK ^\a/b/740UT jjux dPK ^\a/b/741UT jjux dPK ^\a/b/742UT jjux dPK ^\a/b/743UT jjux dPK ^\a/b/744UT jjux dPK ^\a/b/745UT jjux dPK ^\a/b/746UT jjux dPK ^\a/b/747UT jjux dPK ^\a/b/748UT jjux dPK ^\a/b/749UT jjux dPK ^\a/b/750UT jjux dPK ^\a/b/751UT jjux dPK ^\a/b/752UT jjux dPK ^\a/b/753UT jjux dPK ^\a/b/754UT jjux dPK ^\a/b/755UT jjux dPK ^\a/b/756UT jjux dPK ^\a/b/757UT jjux dPK ^\a/b/758UT jjux dPK ^\a/b/759UT jjux dPK ^\a/b/760UT jjux dPK ^\a/b/761UT jjux dPK ^\a/b/762UT jjux dPK ^\a/b/763UT jjux dPK ^\a/b/764UT jjux dPK ^\a/b/765UT jjux dPK ^\a/b/766UT jjux dPK ^\a/b/767UT jjux dPK ^\a/b/768UT jjux dPK ^\a/b/769UT jjux dPK ^\a/b/770UT jjux dPK ^\a/b/771UT jjux dPK ^\a/b/772UT jjux dPK ^\a/b/773UT jjux dPK ^\a/b/774UT jjux dPK ^\a/b/775UT jjux dPK ^\a/b/776UT jjux dPK ^\a/b/777UT jjux dPK ^\a/b/778UT jjux dPK ^\a/b/779UT jjux dPK ^\a/b/780UT jjux dPK ^\a/b/781UT jjux dPK ^\a/b/782UT jjux dPK ^\a/b/783UT jjux dPK ^\a/b/784UT jjux dPK ^\a/b/785UT jjux dPK ^\a/b/786UT jjux dPK ^\a/b/787UT jjux dPK ^\a/b/788UT jjux dPK ^\a/b/789UT jjux dPK ^\a/b/790UT jjux dPK ^\a/b/791UT jjux dPK ^\a/b/792UT jjux dPK ^\a/b/793UT jjux dPK ^\a/b/794UT jjux dPK ^\a/b/795UT jjux dPK ^\a/b/796UT jjux dPK ^\a/b/797UT jjux dPK ^\a/b/798UT jjux dPK ^\a/b/799UT jjux dPK ^\a/b/800UT jjux dPK ^\a/b/801UT jjux dPK ^\a/b/802UT jjux dPK ^\a/b/803UT jjux dPK ^\a/b/804UT jjux dPK ^\a/b/805UT jjux dPK ^\a/b/806UT jjux dPK ^\a/b/807UT jjux dPK ^\a/b/808UT jjux dPK ^\a/b/809UT jjux dPK ^\a/b/810UT jjux dPK ^\a/b/811UT jjux dPK ^\a/b/812UT jjux dPK ^\a/b/813UT jjux dPK ^\a/b/814UT jjux dPK ^\a/b/815UT jjux dPK ^\a/b/816UT jjux dPK ^\a/b/817UT jjux dPK ^\a/b/818UT jjux dPK ^\a/b/819UT jjux dPK ^\a/b/820UT jjux dPK ^\a/b/821UT jjux dPK ^\a/b/822UT jjux dPK ^\a/b/823UT jjux dPK ^\a/b/824UT jjux dPK ^\a/b/825UT jjux dPK ^\a/b/826UT jjux dPK ^\a/b/827UT jjux dPK ^\a/b/828UT jjux dPK ^\a/b/829UT jjux dPK ^\a/b/830UT jjux dPK ^\a/b/831UT jjux dPK ^\a/b/832UT jjux dPK ^\a/b/833UT jjux dPK ^\a/b/834UT jjux dPK ^\a/b/835UT jjux dPK ^\a/b/836UT jjux dPK ^\a/b/837UT jjux dPK ^\a/b/838UT jjux dPK ^\a/b/839UT jjux dPK ^\a/b/840UT jjux dPK ^\a/b/841UT jjux dPK ^\a/b/842UT jjux dPK ^\a/b/843UT jjux dPK ^\a/b/844UT jjux dPK ^\a/b/845UT jjux dPK ^\a/b/846UT jjux dPK ^\a/b/847UT jjux dPK ^\a/b/848UT jjux dPK ^\a/b/849UT jjux dPK ^\a/b/850UT jjux dPK ^\a/b/851UT jjux dPK ^\a/b/852UT jjux dPK ^\a/b/853UT jjux dPK ^\a/b/854UT jjux dPK ^\a/b/855UT jjux dPK ^\a/b/856UT jjux dPK ^\a/b/857UT jjux dPK ^\a/b/858UT jjux dPK ^\a/b/859UT jjux dPK ^\a/b/860UT jjux dPK ^\a/b/861UT jjux dPK ^\a/b/862UT jjux dPK ^\a/b/863UT jjux dPK ^\a/b/864UT jjux dPK ^\a/b/865UT jjux dPK ^\a/b/866UT jjux dPK ^\a/b/867UT jjux dPK ^\a/b/868UT jjux dPK ^\a/b/869UT jjux dPK ^\a/b/870UT jjux dPK ^\a/b/871UT jjux dPK ^\a/b/872UT jjux dPK ^\a/b/873UT jjux dPK ^\a/b/874UT jjux dPK ^\a/b/875UT jjux dPK ^\a/b/876UT jjux dPK ^\a/b/877UT jjux dPK ^\a/b/878UT jjux dPK ^\a/b/879UT jjux dPK ^\a/b/880UT jjux dPK ^\a/b/881UT jjux dPK ^\a/b/882UT jjux dPK ^\a/b/883UT jjux dPK ^\a/b/884UT jjux dPK ^\a/b/885UT jjux dPK ^\a/b/886UT jjux dPK ^\a/b/887UT jjux dPK ^\a/b/888UT jjux dPK ^\a/b/889UT jjux dPK ^\a/b/890UT jjux dPK ^\a/b/891UT jjux dPK ^\a/b/892UT jjux dPK ^\a/b/893UT jjux dPK ^\a/b/894UT jjux dPK ^\a/b/895UT jjux dPK ^\a/b/896UT jjux dPK ^\a/b/897UT jjux dPK ^\a/b/898UT jjux dPK ^\a/b/899UT jjux dPK ^\a/b/900UT jjux dPK ^\a/b/901UT jjux dPK ^\a/b/902UT jjux dPK ^\a/b/903UT jjux dPK ^\a/b/904UT jjux dPK ^\a/b/905UT jjux dPK ^\a/b/906UT jjux dPK ^\a/b/907UT jjux dPK ^\a/b/908UT jjux dPK ^\a/b/909UT jjux dPK ^\a/b/910UT jjux dPK ^\a/b/911UT jjux dPK ^\a/b/912UT jjux dPK ^\a/b/913UT jjux dPK ^\a/b/914UT jjux dPK ^\a/b/915UT jjux dPK ^\a/b/916UT jjux dPK ^\a/b/917UT jjux dPK ^\a/b/918UT jjux dPK ^\a/b/919UT jjux dPK ^\a/b/920UT jjux dPK ^\a/b/921UT jjux dPK ^\a/b/922UT jjux dPK ^\a/b/923UT jjux dPK ^\a/b/924UT jjux dPK ^\a/b/925UT jjux dPK ^\a/b/926UT jjux dPK ^\a/b/927UT jjux dPK ^\a/b/928UT jjux dPK ^\a/b/929UT jjux dPK ^\a/b/930UT jjux dPK ^\a/b/931UT jjux dPK ^\a/b/932UT jjux dPK ^\a/b/933UT jjux dPK ^\a/b/934UT jjux dPK ^\a/b/935UT jjux dPK ^\a/b/936UT jjux dPK ^\a/b/937UT jjux dPK ^\a/b/938UT jjux dPK ^\a/b/939UT jjux dPK ^\a/b/940UT jjux dPK ^\a/b/941UT jjux dPK ^\a/b/942UT jjux dPK ^\a/b/943UT jjux dPK ^\a/b/944UT jjux dPK ^\a/b/945UT jjux dPK ^\a/b/946UT jjux dPK ^\a/b/947UT jjux dPK ^\a/b/948UT jjux dPK ^\a/b/949UT jjux dPK ^\a/b/950UT jjux dPK ^\a/b/951UT jjux dPK ^\a/b/952UT jjux dPK ^\a/b/953UT jjux dPK ^\a/b/954UT jjux dPK ^\a/b/955UT jjux dPK ^\a/b/956UT jjux dPK ^\a/b/957UT jjux dPK ^\a/b/958UT jjux dPK ^\a/b/959UT jjux dPK ^\a/b/960UT jjux dPK ^\a/b/961UT jjux dPK ^\a/b/962UT jjux dPK ^\a/b/963UT jjux dPK ^\a/b/964UT jjux dPK ^\a/b/965UT jjux dPK ^\a/b/966UT jjux dPK ^\a/b/967UT jjux dPK ^\a/b/968UT jjux dPK ^\a/b/969UT jjux dPK ^\a/b/970UT jjux dPK ^\a/b/971UT jjux dPK ^\a/b/972UT jjux dPK ^\a/b/973UT jjux dPK ^\a/b/974UT jjux dPK ^\a/b/975UT jjux dPK ^\a/b/976UT jjux dPK ^\a/b/977UT jjux dPK ^\a/b/978UT jjux dPK ^\a/b/979UT jjux dPK ^\a/b/980UT jjux dPK ^\a/b/981UT jjux dPK ^\a/b/982UT jjux dPK ^\a/b/983UT jjux dPK ^\a/b/984UT jjux dPK ^\a/b/985UT jjux dPK ^\a/b/986UT jjux dPK ^\a/b/987UT jjux dPK ^\a/b/988UT jjux dPK ^\a/b/989UT jjux dPK ^\a/b/990UT jjux dPK ^\a/b/991UT jjux dPK ^\a/b/992UT jjux dPK ^\a/b/993UT jjux dPK ^\a/b/994UT jjux dPK ^\a/b/995UT jjux dPK ^\a/b/996UT jjux dPK ^\a/b/997UT jjux dPK ^\a/b/998UT jjux dPK ^\a/b/999UT jjux dPK ]\P0x21000UT(jux dPK ]\AAa/UTujux dPK ]\O}a/longlonglonglonglonglonglonglonglonglonglonglonglonglonglongkindalongname.txtUTujux dPK ^\Aa/b/UTjux dPK ]\ADa/b/c/UT>jux dPK]\P a/b/c/0x21000UT>jux dPK ^\^a/b/000UTjux dPK ^\a/b/001UTjux dPK ^\a/b/002UTjux dPK ^\!a/b/003UTjux dPK ^\ba/b/004UTjux dPK ^\a/b/005UTjux dPK ^\a/b/006UTjux dPK ^\%a/b/007UTjux dPK ^\fa/b/008UTjux dPK ^\a/b/009UTjux dPK ^\a/b/010UTjux dPK ^\)a/b/011UTjux dPK ^\ja/b/012UTjux dPK ^\a/b/013UTjux dPK ^\a/b/014UTjux dPK ^\-a/b/015UTjux dPK ^\na/b/016UTjux dPK ^\a/b/017UTjux dPK ^\a/b/018UTjux dPK ^\1a/b/019UTjux dPK ^\ra/b/020UTjux dPK ^\a/b/021UTjux dPK ^\a/b/022UTjux dPK ^\5a/b/023UTjux dPK ^\va/b/024UTjux dPK ^\a/b/025UTjux dPK ^\a/b/026UTjux dPK ^\9a/b/027UTjux dPK ^\za/b/028UTjux dPK ^\a/b/029UTjux dPK ^\a/b/030UTjux dPK ^\=a/b/031UTjux dPK ^\~a/b/032UTjux dPK ^\a/b/033UTjux dPK ^\a/b/034UTjux dPK ^\Aa/b/035UTjux dPK ^\a/b/036UTjux dPK ^\a/b/037UTjux dPK ^\a/b/038UTjux dPK ^\Ea/b/039UTjux dPK ^\a/b/040UTjux dPK ^\a/b/041UTjux dPK ^\a/b/042UTjux dPK ^\Ia/b/043UTjux dPK ^\a/b/044UTjux dPK ^\a/b/045UTjux dPK ^\ a/b/046UTjux dPK ^\Ma/b/047UTjux dPK ^\a/b/048UTjux dPK ^\a/b/049UTjux dPK ^\a/b/050UTjux dPK ^\Qa/b/051UTjux dPK ^\a/b/052UTjux dPK ^\a/b/053UTjux dPK ^\ a/b/054UTjux dPK ^\U a/b/055UTjux dPK ^\ a/b/056UTjux dPK ^\ a/b/057UTjux dPK ^\!a/b/058UTjux dPK ^\Y!a/b/059UTjux dPK ^\!a/b/060UTjux dPK ^\!a/b/061UTjux dPK ^\"a/b/062UTjux dPK ^\]"a/b/063UTjux dPK ^\"a/b/064UTjux dPK ^\"a/b/065UTjux dPK ^\ #a/b/066UTjux dPK ^\a#a/b/067UTjux dPK ^\#a/b/068UTjux dPK ^\#a/b/069UTjux dPK ^\$$a/b/070UTjux dPK ^\e$a/b/071UTjux dPK ^\$a/b/072UTjux dPK ^\$a/b/073UTjux dPK ^\(%a/b/074UTjux dPK ^\i%a/b/075UTjux dPK ^\%a/b/076UTjux dPK ^\%a/b/077UTjux dPK ^\,&a/b/078UTjux dPK ^\m&a/b/079UTjux dPK ^\&a/b/080UTjux dPK ^\&a/b/081UTjux dPK ^\0'a/b/082UTjux dPK ^\q'a/b/083UTjux dPK ^\'a/b/084UTjux dPK ^\'a/b/085UTjux dPK ^\4(a/b/086UTjux dPK ^\u(a/b/087UTjux dPK ^\(a/b/088UTjux dPK ^\(a/b/089UTjux dPK ^\8)a/b/090UTjux dPK ^\y)a/b/091UTjux dPK ^\)a/b/092UTjux dPK ^\)a/b/093UTjux dPK ^\<*a/b/094UTjux dPK ^\}*a/b/095UTjux dPK ^\*a/b/096UTjux dPK ^\*a/b/097UTjux dPK ^\@+a/b/098UTjux dPK ^\+a/b/099UTjux dPK ^\+a/b/100UTjux dPK ^\,a/b/101UTjux dPK ^\D,a/b/102UTjux dPK ^\,a/b/103UTjux dPK ^\,a/b/104UTjux dPK ^\-a/b/105UTjux dPK ^\H-a/b/106UTjux dPK ^\-a/b/107UTjux dPK ^\-a/b/108UTjux dPK ^\ .a/b/109UTjux dPK ^\L.a/b/110UTjux dPK ^\.a/b/111UTjux dPK ^\.a/b/112UTjux dPK ^\/a/b/113UTjux dPK ^\P/a/b/114UTjux dPK ^\/a/b/115UTjux dPK ^\/a/b/116UTjux dPK ^\0a/b/117UTjux dPK ^\T0a/b/118UTjux dPK ^\0a/b/119UTjux dPK ^\0a/b/120UTjux dPK ^\1a/b/121UTjux dPK ^\X1a/b/122UTjux dPK ^\1a/b/123UTjux dPK ^\1a/b/124UTjux dPK ^\2a/b/125UTjux dPK ^\\2a/b/126UTjux dPK ^\2a/b/127UTjux dPK ^\2a/b/128UTjux dPK ^\3a/b/129UTjux dPK ^\`3a/b/130UTjux dPK ^\3a/b/131UTjux dPK ^\3a/b/132UTjux dPK ^\#4a/b/133UTjux dPK ^\d4a/b/134UTjux dPK ^\4a/b/135UTjux dPK ^\4a/b/136UTjux dPK ^\'5a/b/137UTjux dPK ^\h5a/b/138UTjux dPK ^\5a/b/139UTjux dPK ^\5a/b/140UTjux dPK ^\+6a/b/141UTjux dPK ^\l6a/b/142UTjux dPK ^\6a/b/143UTjux dPK ^\6a/b/144UTjux dPK ^\/7a/b/145UTjux dPK ^\p7a/b/146UTjux dPK ^\7a/b/147UTjux dPK ^\7a/b/148UTjux dPK ^\38a/b/149UTjux dPK ^\t8a/b/150UTjux dPK ^\8a/b/151UTjux dPK ^\8a/b/152UTjux dPK ^\79a/b/153UTjux dPK ^\x9a/b/154UTjux dPK ^\9a/b/155UTjux dPK ^\9a/b/156UTjux dPK ^\;:a/b/157UTjux dPK ^\|:a/b/158UTjux dPK ^\:a/b/159UTjux dPK ^\:a/b/160UTjux dPK ^\?;a/b/161UTjux dPK ^\;a/b/162UTjux dPK ^\;a/b/163UTjux dPK ^\<a/b/164UTjux dPK ^\C<a/b/165UTjux dPK ^\<a/b/166UTjux dPK ^\<a/b/167UTjux dPK ^\=a/b/168UTjux dPK ^\G=a/b/169UTjux dPK ^\=a/b/170UTjux dPK ^\=a/b/171UTjux dPK ^\ >a/b/172UTjux dPK ^\K>a/b/173UTjux dPK ^\>a/b/174UTjux dPK ^\>a/b/175UTjux dPK ^\?a/b/176UTjux dPK ^\O?a/b/177UTjux dPK ^\?a/b/178UTjux dPK ^\?a/b/179UTjux dPK ^\@a/b/180UTjux dPK ^\S@a/b/181UTjux dPK ^\@a/b/182UTjux dPK ^\@a/b/183UTjux dPK ^\Aa/b/184UTjux dPK ^\WAa/b/185UTjux dPK ^\Aa/b/186UTjux dPK ^\Aa/b/187UTjux dPK ^\Ba/b/188UTjux dPK ^\[Ba/b/189UTjux dPK ^\Ba/b/190UTjux dPK ^\Ba/b/191UTjux dPK ^\Ca/b/192UTjux dPK ^\_Ca/b/193UTjux dPK ^\Ca/b/194UTjux dPK ^\Ca/b/195UTjux dPK ^\"Da/b/196UTjux dPK ^\cDa/b/197UTjux dPK ^\Da/b/198UTjux dPK ^\Da/b/199UTjux dPK ^\&Ea/b/200UTjux dPK ^\gEa/b/201UTjux dPK ^\Ea/b/202UTjux dPK ^\Ea/b/203UTjux dPK ^\*Fa/b/204UTjux dPK ^\kFa/b/205UTjux dPK ^\Fa/b/206UTjux dPK ^\Fa/b/207UTjux dPK ^\.Ga/b/208UTjux dPK ^\oGa/b/209UTjux dPK ^\Ga/b/210UTjux dPK ^\Ga/b/211UTjux dPK ^\2Ha/b/212UTjux dPK ^\sHa/b/213UTjux dPK ^\Ha/b/214UTjux dPK ^\Ha/b/215UTjux dPK ^\6Ia/b/216UTjux dPK ^\wIa/b/217UTjux dPK ^\Ia/b/218UTjux dPK ^\Ia/b/219UTjux dPK ^\:Ja/b/220UTjux dPK ^\{Ja/b/221UTjux dPK ^\Ja/b/222UTjux dPK ^\Ja/b/223UTjux dPK ^\>Ka/b/224UTjux dPK ^\Ka/b/225UTjux dPK ^\Ka/b/226UTjux dPK ^\La/b/227UTjux dPK ^\BLa/b/228UTjux dPK ^\La/b/229UTjux dPK ^\La/b/230UTjux dPK ^\Ma/b/231UTjux dPK ^\FMa/b/232UTjux dPK ^\Ma/b/233UTjux dPK ^\Ma/b/234UTjux dPK ^\ Na/b/235UTjux dPK ^\JNa/b/236UTjux dPK ^\Na/b/237UTjux dPK ^\Na/b/238UTjux dPK ^\ Oa/b/239UTjux dPK ^\NOa/b/240UTjux dPK ^\Oa/b/241UTjux dPK ^\Oa/b/242UTjux dPK ^\Pa/b/243UTjux dPK ^\RPa/b/244UTjux dPK ^\Pa/b/245UTjux dPK ^\Pa/b/246UTjux dPK ^\Qa/b/247UTjux dPK ^\VQa/b/248UTjux dPK ^\Qa/b/249UTjux dPK ^\Qa/b/250UTjux dPK ^\Ra/b/251UTjux dPK ^\ZRa/b/252UTjux dPK ^\Ra/b/253UTjux dPK ^\Ra/b/254UTjux dPK ^\Sa/b/255UTjux dPK ^\^Sa/b/256UTjux dPK ^\Sa/b/257UTjux dPK ^\Sa/b/258UTjux dPK ^\!Ta/b/259UTjux dPK ^\bTa/b/260UTjux dPK ^\Ta/b/261UTjux dPK ^\Ta/b/262UTjux dPK ^\%Ua/b/263UTjux dPK ^\fUa/b/264UTjux dPK ^\Ua/b/265UTjux dPK ^\Ua/b/266UTjux dPK ^\)Va/b/267UTjux dPK ^\jVa/b/268UTjux dPK ^\Va/b/269UTjux dPK ^\Va/b/270UTjux dPK ^\-Wa/b/271UTjux dPK ^\nWa/b/272UTjux dPK ^\Wa/b/273UTjux dPK ^\Wa/b/274UTjux dPK ^\1Xa/b/275UTjux dPK ^\rXa/b/276UTjux dPK ^\Xa/b/277UTjux dPK ^\Xa/b/278UTjux dPK ^\5Ya/b/279UTjux dPK ^\vYa/b/280UTjux dPK ^\Ya/b/281UTjux dPK ^\Ya/b/282UTjux dPK ^\9Za/b/283UTjux dPK ^\zZa/b/284UTjux dPK ^\Za/b/285UTjux dPK ^\Za/b/286UTjux dPK ^\=[a/b/287UTjux dPK ^\~[a/b/288UTjux dPK ^\[a/b/289UTjux dPK ^\\a/b/290UTjux dPK ^\A\a/b/291UTjux dPK ^\\a/b/292UTjux dPK ^\\a/b/293UTjux dPK ^\]a/b/294UTjux dPK ^\E]a/b/295UTjux dPK ^\]a/b/296UTjux dPK ^\]a/b/297UTjux dPK ^\^a/b/298UTjux dPK ^\I^a/b/299UTjux dPK ^\^a/b/300UTjux dPK ^\^a/b/301UTjux dPK ^\ _a/b/302UTjux dPK ^\M_a/b/303UTjux dPK ^\_a/b/304UTjux dPK ^\_a/b/305UTjux dPK ^\`a/b/306UTjux dPK ^\Q`a/b/307UTjux dPK ^\`a/b/308UTjux dPK ^\`a/b/309UTjux dPK ^\aa/b/310UTjux dPK ^\Uaa/b/311UTjux dPK ^\aa/b/312UTjux dPK ^\aa/b/313UTjux dPK ^\ba/b/314UTjux dPK ^\Yba/b/315UTjux dPK ^\ba/b/316UTjux dPK ^\ba/b/317UTjux dPK ^\ca/b/318UTjux dPK ^\]ca/b/319UTjux dPK ^\ca/b/320UTjux dPK ^\ca/b/321UTjux dPK ^\ da/b/322UTjux dPK ^\ada/b/323UTjux dPK ^\da/b/324UTjux dPK ^\da/b/325UTjux dPK ^\$ea/b/326UTjux dPK ^\eea/b/327UTjux dPK ^\ea/b/328UTjux dPK ^\ea/b/329UTjux dPK ^\(fa/b/330UTjux dPK ^\ifa/b/331UTjux dPK ^\fa/b/332UTjux dPK ^\fa/b/333UTjux dPK ^\,ga/b/334UTjux dPK ^\mga/b/335UTjux dPK ^\ga/b/336UTjux dPK ^\ga/b/337UTjux dPK ^\0ha/b/338UTjux dPK ^\qha/b/339UTjux dPK ^\ha/b/340UTjux dPK ^\ha/b/341UTjux dPK ^\4ia/b/342UTjux dPK ^\uia/b/343UTjux dPK ^\ia/b/344UTjux dPK ^\ia/b/345UTjux dPK ^\8ja/b/346UTjux dPK ^\yja/b/347UTjux dPK ^\ja/b/348UTjux dPK ^\ja/b/349UTjux dPK ^\a/b/480UTjux dPK ^\a/b/481UTjux dPK ^\a/b/482UTjux dPK ^\a/b/483UTjux dPK ^\Ba/b/484UTjux dPK ^\a/b/485UTjux dPK ^\ča/b/486UTjux dPK ^\a/b/487UTjux dPK ^\Fa/b/488UTjux dPK ^\a/b/489UTjux dPK ^\Ȏa/b/490UTjux dPK ^\ a/b/491UTjux dPK ^\Ja/b/492UTjux dPK ^\a/b/493UTjux dPK ^\̏a/b/494UTjux dPK ^\ a/b/495UTjux dPK ^\Na/b/496UTjux dPK ^\a/b/497UTjux dPK ^\Аa/b/498UTjux dPK ^\a/b/499UTjux dPK ^\Ra/b/500UTjux dPK ^\a/b/501UTjux dPK ^\ԑa/b/502UTjux dPK ^\a/b/503UTjux dPK ^\Va/b/504UTjux dPK ^\a/b/505UTjux dPK ^\ؒa/b/506UTjux dPK ^\a/b/507UTjux dPK ^\Za/b/508UTjux dPK ^\a/b/509UTjux dPK ^\ܓa/b/510UTjux dPK ^\a/b/511UTjux dPK ^\^a/b/512UTjux dPK ^\a/b/513UTjux dPK ^\a/b/514UTjux dPK ^\!a/b/515UTjux dPK ^\ba/b/516UTjux dPK ^\a/b/517UTjux dPK ^\a/b/518UTjux dPK ^\%a/b/519UTjux dPK ^\fa/b/520UTjux dPK ^\a/b/521UTjux dPK ^\a/b/522UTjux dPK ^\)a/b/523UTjux dPK ^\ja/b/524UTjux dPK ^\a/b/525UTjux dPK ^\a/b/526UTjux dPK ^\-a/b/527UTjux dPK ^\na/b/528UTjux dPK ^\a/b/529UTjux dPK ^\a/b/530UTjux dPK ^\1a/b/531UTjux dPK ^\ra/b/532UTjux dPK ^\a/b/533UTjux dPK ^\a/b/534UTjux dPK ^\5a/b/535UTjux dPK ^\va/b/536UTjux dPK ^\a/b/537UTjux dPK ^\a/b/538UTjux dPK ^\9a/b/539UTjux dPK ^\za/b/540UTjux dPK ^\a/b/541UTjux dPK ^\a/b/542UTjux dPK ^\=a/b/543UTjux dPK ^\~a/b/544UTjux dPK ^\a/b/545UTjux dPK ^\a/b/546UTjux dPK ^\Aa/b/547UTjux dPK ^\a/b/548UTjux dPK ^\Ýa/b/549UTjux dPK ^\a/b/550UTjux dPK ^\Ea/b/551UTjux dPK ^\a/b/552UTjux dPK ^\Ǟa/b/553UTjux dPK ^\a/b/554UTjux dPK ^\Ia/b/555UTjux dPK ^\a/b/556UTjux dPK ^\˟a/b/557UTjux dPK ^\ a/b/558UTjux dPK ^\Ma/b/559UTjux dPK ^\a/b/560UTjux dPK ^\Ϡa/b/561UTjux dPK ^\a/b/562UTjux dPK ^\Qa/b/563UTjux dPK ^\a/b/564UTjux dPK ^\ӡa/b/565UTjux dPK ^\a/b/566UTjux dPK ^\Ua/b/567UTjux dPK ^\a/b/568UTjux dPK ^\עa/b/569UTjux dPK ^\a/b/570UTjux dPK ^\Ya/b/571UTjux dPK ^\a/b/572UTjux dPK ^\ۣa/b/573UTjux dPK ^\a/b/574UTjux dPK ^\]a/b/575UTjux dPK ^\a/b/576UTjux dPK ^\ߤa/b/577UTjux dPK ^\ a/b/578UTjux dPK ^\aa/b/579UTjux dPK ^\a/b/580UTjux dPK ^\a/b/581UTjux dPK ^\$a/b/582UTjux dPK ^\ea/b/583UTjux dPK ^\a/b/584UTjux dPK ^\a/b/585UTjux dPK ^\(a/b/586UTjux dPK ^\ia/b/587UTjux dPK ^\a/b/588UTjux dPK ^\a/b/589UTjux dPK ^\,a/b/590UTjux dPK ^\ma/b/591UTjux dPK ^\a/b/592UTjux dPK ^\a/b/593UTjux dPK ^\0a/b/594UTjux dPK ^\qa/b/595UTjux dPK ^\a/b/596UTjux dPK ^\a/b/597UTjux dPK ^\4a/b/598UTjux dPK ^\ua/b/599UTjux dPK ^\a/b/600UTjux dPK ^\a/b/601UTjux dPK ^\8a/b/602UTjux dPK ^\ya/b/603UTjux dPK ^\a/b/604UTjux dPK ^\a/b/605UTjux dPK ^\<a/b/606UTjux dPK ^\}a/b/607UTjux dPK ^\a/b/608UTjux dPK ^\a/b/609UTjux dPK ^\@a/b/610UTjux dPK ^\a/b/611UTjux dPK ^\­a/b/612UTjux dPK ^\a/b/613UTjux dPK ^\Da/b/614UTjux dPK ^\a/b/615UTjux dPK ^\Ʈa/b/616UTjux dPK ^\a/b/617UTjux dPK ^\Ha/b/618UTjux dPK ^\a/b/619UTjux dPK ^\ʯa/b/620UTjux dPK ^\ a/b/621UTjux dPK ^\La/b/622UTjux dPK ^\a/b/623UTjux dPK ^\ΰa/b/624UTjux dPK ^\a/b/625UTjux dPK ^\Pa/b/626UTjux dPK ^\a/b/627UTjux dPK ^\ұa/b/628UTjux dPK ^\a/b/629UTjux dPK ^\Ta/b/630UTjux dPK ^\a/b/631UTjux dPK ^\ֲa/b/632UTjux dPK ^\a/b/633UTjux dPK ^\Xa/b/634UTjux dPK ^\a/b/635UTjux dPK ^\ڳa/b/636UTjux dPK ^\a/b/637UTjux dPK ^\\a/b/638UTjux dPK ^\a/b/639UTjux dPK ^\޴a/b/640UTjux dPK ^\a/b/641UTjux dPK ^\`a/b/642UTjux dPK ^\a/b/643UTjux dPK ^\a/b/644UTjux dPK ^\#a/b/645UTjux dPK ^\da/b/646UTjux dPK ^\a/b/647UTjux dPK ^\a/b/648UTjux dPK ^\'a/b/649UTjux dPK ^\ha/b/650UTjux dPK ^\a/b/651UTjux dPK ^\a/b/652UTjux dPK ^\+a/b/653UTjux dPK ^\la/b/654UTjux dPK ^\a/b/655UTjux dPK ^\a/b/656UTjux dPK ^\/a/b/657UTjux dPK ^\pa/b/658UTjux dPK ^\a/b/659UTjux dPK ^\a/b/660UTjux dPK ^\3a/b/661UTjux dPK ^\ta/b/662UTjux dPK ^\a/b/663UTjux dPK ^\a/b/664UTjux dPK ^\7a/b/665UTjux dPK ^\xa/b/666UTjux dPK ^\a/b/667UTjux dPK ^\a/b/668UTjux dPK ^\;a/b/669UTjux dPK ^\|a/b/670UTjux dPK ^\a/b/671UTjux dPK ^\a/b/672UTjux dPK ^\?a/b/673UTjux dPK ^\a/b/674UTjux dPK ^\a/b/675UTjux dPK ^\a/b/676UTjux dPK ^\Ca/b/677UTjux dPK ^\a/b/678UTjux dPK ^\ža/b/679UTjux dPK ^\a/b/680UTjux dPK ^\Ga/b/681UTjux dPK ^\a/b/682UTjux dPK ^\ɿa/b/683UTjux dPK ^\ a/b/684UTjux dPK ^\Ka/b/685UTjux dPK ^\a/b/686UTjux dPK ^\a/b/687UTjux dPK ^\a/b/688UTjux dPK ^\Oa/b/689UTjux dPK ^\a/b/690UTjux dPK ^\a/b/691UTjux dPK ^\a/b/692UTjux dPK ^\Sa/b/693UTjux dPK ^\a/b/694UTjux dPK ^\a/b/695UTjux dPK ^\a/b/696UTjux dPK ^\Wa/b/697UTjux dPK ^\a/b/698UTjux dPK ^\a/b/699UTjux dPK ^\a/b/700UTjux dPK ^\[a/b/701UTjux dPK ^\a/b/702UTjux dPK ^\a/b/703UTjux dPK ^\a/b/704UTjux dPK ^\_a/b/705UTjux dPK ^\a/b/706UTjux dPK ^\a/b/707UTjux dPK ^\"a/b/708UTjux dPK ^\ca/b/709UTjux dPK ^\a/b/710UTjux dPK ^\a/b/711UTjux dPK ^\&a/b/712UTjux dPK ^\ga/b/713UTjux dPK ^\a/b/714UTjux dPK ^\a/b/715UTjux dPK ^\*a/b/716UTjux dPK ^\ka/b/717UTjux dPK ^\a/b/718UTjux dPK ^\a/b/719UTjux dPK ^\.a/b/720UTjux dPK ^\oa/b/721UTjux dPK ^\a/b/722UTjux dPK ^\a/b/723UTjux dPK ^\2a/b/724UTjux dPK ^\sa/b/725UTjux dPK ^\a/b/726UTjux dPK ^\a/b/727UTjux dPK ^\6a/b/728UTjux dPK ^\wa/b/729UTjux dPK ^\a/b/730UTjux dPK ^\a/b/731UTjux dPK ^\:a/b/732UTjux dPK ^\{a/b/733UTjux dPK ^\a/b/734UTjux dPK ^\a/b/735UTjux dPK ^\>a/b/736UTjux dPK ^\a/b/737UTjux dPK ^\a/b/738UTjux dPK ^\a/b/739UTjux dPK ^\Ba/b/740UTjux dPK ^\a/b/741UTjux dPK ^\a/b/742UTjux dPK ^\a/b/743UTjux dPK ^\Fa/b/744UTjux dPK ^\a/b/745UTjux dPK ^\a/b/746UTjux dPK ^\ a/b/747UTjux dPK ^\Ja/b/748UTjux dPK ^\a/b/749UTjux dPK ^\a/b/750UTjux dPK ^\ a/b/751UTjux dPK ^\Na/b/752UTjux dPK ^\a/b/753UTjux dPK ^\a/b/754UTjux dPK ^\a/b/755UTjux dPK ^\Ra/b/756UTjux dPK ^\a/b/757UTjux dPK ^\a/b/758UTjux dPK ^\a/b/759UTjux dPK ^\Va/b/760UTjux dPK ^\a/b/761UTjux dPK ^\a/b/762UTjux dPK ^\a/b/763UTjux dPK ^\Za/b/764UTjux dPK ^\a/b/765UTjux dPK ^\a/b/766UTjux dPK ^\a/b/767UTjux dPK ^\^a/b/768UTjux dPK ^\a/b/769UTjux dPK ^\a/b/770UTjux dPK ^\!a/b/771UTjux dPK ^\ba/b/772UTjux dPK ^\a/b/773UTjux dPK ^\a/b/774UTjux dPK ^\%a/b/775UTjux dPK ^\fa/b/776UTjux dPK ^\a/b/777UTjux dPK ^\a/b/778UTjux dPK ^\)a/b/779UTjux dPK ^\ja/b/780UTjux dPK ^\a/b/781UTjux dPK ^\a/b/782UTjux dPK ^\-a/b/783UTjux dPK ^\na/b/784UTjux dPK ^\a/b/785UTjux dPK ^\a/b/786UTjux dPK ^\1a/b/787UTjux dPK ^\ra/b/788UTjux dPK ^\a/b/789UTjux dPK ^\a/b/790UTjux dPK ^\5a/b/791UTjux dPK ^\va/b/792UTjux dPK ^\a/b/793UTjux dPK ^\a/b/794UTjux dPK ^\9a/b/795UTjux dPK ^\za/b/796UTjux dPK ^\a/b/797UTjux dPK ^\a/b/798UTjux dPK ^\=a/b/799UTjux dPK ^\~a/b/800UTjux dPK ^\a/b/801UTjux dPK ^\a/b/802UTjux dPK ^\Aa/b/803UTjux dPK ^\a/b/804UTjux dPK ^\a/b/805UTjux dPK ^\a/b/806UTjux dPK ^\Ea/b/807UTjux dPK ^\a/b/808UTjux dPK ^\a/b/809UTjux dPK ^\a/b/810UTjux dPK ^\Ia/b/811UTjux dPK ^\a/b/812UTjux dPK ^\a/b/813UTjux dPK ^\ a/b/814UTjux dPK ^\Ma/b/815UTjux dPK ^\a/b/816UTjux dPK ^\a/b/817UTjux dPK ^\a/b/818UTjux dPK ^\Qa/b/819UTjux dPK ^\a/b/820UTjux dPK ^\a/b/821UTjux dPK ^\a/b/822UTjux dPK ^\Ua/b/823UTjux dPK ^\a/b/824UTjux dPK ^\a/b/825UTjux dPK ^\a/b/826UTjux dPK ^\Ya/b/827UTjux dPK ^\a/b/828UTjux dPK ^\a/b/829UTjux dPK ^\a/b/830UTjux dPK ^\]a/b/831UTjux dPK ^\a/b/832UTjux dPK ^\a/b/833UTjux dPK ^\ a/b/834UTjux dPK ^\aa/b/835UTjux dPK ^\a/b/836UTjux dPK ^\a/b/837UTjux dPK ^\$a/b/838UTjux dPK ^\ea/b/839UTjux dPK ^\a/b/840UTjux dPK ^\a/b/841UTjux dPK ^\(a/b/842UTjux dPK ^\ia/b/843UTjux dPK ^\a/b/844UTjux dPK ^\a/b/845UTjux dPK ^\,a/b/846UTjux dPK ^\ma/b/847UTjux dPK ^\a/b/848UTjux dPK ^\a/b/849UTjux dPK ^\0a/b/850UTjux dPK ^\qa/b/851UTjux dPK ^\a/b/852UTjux dPK ^\a/b/853UTjux dPK ^\4a/b/854UTjux dPK ^\ua/b/855UTjux dPK ^\a/b/856UTjux dPK ^\a/b/857UTjux dPK ^\8a/b/858UTjux dPK ^\ya/b/859UTjux dPK ^\a/b/860UTjux dPK ^\a/b/861UTjux dPK ^\<a/b/862UTjux dPK ^\}a/b/863UTjux dPK ^\a/b/864UTjux dPK ^\a/b/865UTjux dPK ^\@a/b/866UTjux dPK ^\a/b/867UTjux dPK ^\a/b/868UTjux dPK ^\a/b/869UTjux dPK ^\Da/b/870UTjux dPK ^\a/b/871UTjux dPK ^\a/b/872UTjux dPK ^\a/b/873UTjux dPK ^\Ha/b/874UTjux dPK ^\a/b/875UTjux dPK ^\a/b/876UTjux dPK ^\ a/b/877UTjux dPK ^\La/b/878UTjux dPK ^\a/b/879UTjux dPK ^\a/b/880UTjux dPK ^\a/b/881UTjux dPK ^\Pa/b/882UTjux dPK ^\a/b/883UTjux dPK ^\a/b/884UTjux dPK ^\a/b/885UTjux dPK ^\Ta/b/886UTjux dPK ^\a/b/887UTjux dPK ^\a/b/888UTjux dPK ^\a/b/889UTjux dPK ^\Xa/b/890UTjux dPK ^\a/b/891UTjux dPK ^\a/b/892UTjux dPK ^\a/b/893UTjux dPK ^\\a/b/894UTjux dPK ^\a/b/895UTjux dPK ^\a/b/896UTjux dPK ^\a/b/897UTjux dPK ^\`a/b/898UTjux dPK ^\a/b/899UTjux dPK ^\a/b/900UTjux dPK ^\#a/b/901UTjux dPK ^\da/b/902UTjux dPK ^\a/b/903UTjux dPK ^\a/b/904UTjux dPK ^\'a/b/905UTjux dPK ^\ha/b/906UTjux dPK ^\a/b/907UTjux dPK ^\a/b/908UTjux dPK ^\+a/b/909UTjux dPK ^\la/b/910UTjux dPK ^\a/b/911UTjux dPK ^\a/b/912UTjux dPK ^\/a/b/913UTjux dPK ^\pa/b/914UTjux dPK ^\a/b/915UTjux dPK ^\a/b/916UTjux dPK ^\3a/b/917UTjux dPK ^\ta/b/918UTjux dPK ^\a/b/919UTjux dPK ^\a/b/920UTjux dPK ^\7a/b/921UTjux dPK ^\xa/b/922UTjux dPK ^\a/b/923UTjux dPK ^\a/b/924UTjux dPK ^\;a/b/925UTjux dPK ^\|a/b/926UTjux dPK ^\a/b/927UTjux dPK ^\a/b/928UTjux dPK ^\?a/b/929UTjux dPK ^\a/b/930UTjux dPK ^\a/b/931UTjux dPK ^\a/b/932UTjux dPK ^\Ca/b/933UTjux dPK ^\a/b/934UTjux dPK ^\a/b/935UTjux dPK ^\a/b/936UTjux dPK ^\Ga/b/937UTjux dPK ^\a/b/938UTjux dPK ^\a/b/939UTjux dPK ^\ a/b/940UTjux dPK ^\Ka/b/941UTjux dPK ^\a/b/942UTjux dPK ^\a/b/943UTjux dPK ^\a/b/944UTjux dPK ^\Oa/b/945UTjux dPK ^\a/b/946UTjux dPK ^\a/b/947UTjux dPK ^\a/b/948UTjux dPK ^\Sa/b/949UTjux dPK ^\a/b/950UTjux dPK ^\a/b/951UTjux dPK ^\a/b/952UTjux dPK ^\Wa/b/953UTjux dPK ^\a/b/954UTjux dPK ^\a/b/955UTjux dPK ^\a/b/956UTjux dPK ^\[a/b/957UTjux dPK ^\a/b/958UTjux dPK ^\a/b/959UTjux dPK ^\a/b/960UTjux dPK ^\_a/b/961UTjux dPK ^\a/b/962UTjux dPK ^\a/b/963UTjux dPK ^\"a/b/964UTjux dPK ^\ca/b/965UTjux dPK ^\a/b/966UTjux dPK ^\a/b/967UTjux dPK ^\&a/b/968UTjux dPK ^\ga/b/969UTjux dPK ^\a/b/970UTjux dPK ^\a/b/971UTjux dPK ^\* a/b/972UTjux dPK ^\k a/b/973UTjux dPK ^\ a/b/974UTjux dPK ^\ a/b/975UTjux dPK ^\. a/b/976UTjux dPK ^\o a/b/977UTjux dPK ^\ a/b/978UTjux dPK ^\ a/b/979UTjux dPK ^\2 a/b/980UTjux dPK ^\s a/b/981UTjux dPK ^\ a/b/982UTjux dPK ^\ a/b/983UTjux dPK ^\6 a/b/984UTjux dPK ^\w a/b/985UTjux dPK ^\ a/b/986UTjux dPK ^\ a/b/987UTjux dPK ^\: a/b/988UTjux dPK ^\{ a/b/989UTjux dPK ^\ a/b/990UTjux dPK ^\ a/b/991UTjux dPK ^\>a/b/992UTjux dPK ^\a/b/993UTjux dPK ^\a/b/994UTjux dPK ^\a/b/995UTjux dPK ^\Ba/b/996UTjux dPK ^\a/b/997UTjux dPK ^\a/b/998UTjux dPK ^\a/b/999UTjux dPK.Fyauzl-3.4.0/test/success/everything/000077500000000000000000000000001521126516100174755ustar00rootroot00000000000000yauzl-3.4.0/test/success/everything/0x21000000066400000000000000000004100001521126516100203250ustar00rootroot00000000000000yauzl-3.4.0/test/success/everything/a/000077500000000000000000000000001521126516100177155ustar00rootroot00000000000000yauzl-3.4.0/test/success/everything/a/b/000077500000000000000000000000001521126516100201365ustar00rootroot00000000000000yauzl-3.4.0/test/success/everything/a/b/c/000077500000000000000000000000001521126516100203605ustar00rootroot00000000000000yauzl-3.4.0/test/success/everything/a/b/c/0x21000000066400000000000000000004100001521126516100212100ustar00rootroot00000000000000longlonglonglonglonglonglonglonglonglonglonglonglonglonglongkindalongname.txt000066400000000000000000000000001521126516100377140ustar00rootroot00000000000000yauzl-3.4.0/test/success/everything/ayauzl-3.4.0/test/success/linux-info-zip.zip000066400000000000000000000004641521126516100207310ustar00rootroot00000000000000PK KEQVa.txtUT >*S>*Sux asdf PK KEb.txtUT >*S>*Sux bsdf PK KEQVa.txtUT>*Sux PK KEDb.txtUT>*Sux PKyauzl-3.4.0/test/success/linux-info-zip/000077500000000000000000000000001521126516100202015ustar00rootroot00000000000000yauzl-3.4.0/test/success/linux-info-zip/a.txt000066400000000000000000000000051521126516100211550ustar00rootroot00000000000000asdf yauzl-3.4.0/test/success/linux-info-zip/b.txt000066400000000000000000000000051521126516100211560ustar00rootroot00000000000000bsdf yauzl-3.4.0/test/success/sloppy-filenames.zip000066400000000000000000000004641521126516100213300ustar00rootroot00000000000000PK KEQVa.txtUT >*S>*Sux asdf PK KEb.txtUT >*S>*Sux bsdf PK KEQVa\txtUT>*Sux PK KEDb.txtUT>*Sux PKyauzl-3.4.0/test/success/sloppy-filenames/000077500000000000000000000000001521126516100206005ustar00rootroot00000000000000yauzl-3.4.0/test/success/sloppy-filenames/a/000077500000000000000000000000001521126516100210205ustar00rootroot00000000000000yauzl-3.4.0/test/success/sloppy-filenames/a/.dont_expect_an_empty_dir_entry_for_this_dir000066400000000000000000000000001521126516100320310ustar00rootroot00000000000000yauzl-3.4.0/test/success/sloppy-filenames/a/txt000066400000000000000000000000051521126516100215550ustar00rootroot00000000000000asdf yauzl-3.4.0/test/success/sloppy-filenames/b.txt000066400000000000000000000000051521126516100215550ustar00rootroot00000000000000bsdf yauzl-3.4.0/test/success/streaming.zip000066400000000000000000000004241521126516100200260ustar00rootroot00000000000000PK3cZ test1.txtKOÆPKOPK3cZ test2.txtKJ,J†PK4 PK?3cZO test1.txtUTgPK?3cZ4  ?test2.txtUTgPK~yauzl-3.4.0/test/success/streaming/000077500000000000000000000000001521126516100173025ustar00rootroot00000000000000yauzl-3.4.0/test/success/streaming/test1.txt000066400000000000000000000000311521126516100210750ustar00rootroot00000000000000foofoofoofoofoofoofoofoo yauzl-3.4.0/test/success/streaming/test2.txt000066400000000000000000000000311521126516100210760ustar00rootroot00000000000000barbarbarbarbarbarbarbar yauzl-3.4.0/test/success/traditional-encryption-and-compression.zip000066400000000000000000000003071521126516100256360ustar00rootroot00000000000000PK J a.binUT iXiXux c.,"s IX}Y`PK PK J a.binUTiXux PKKfyauzl-3.4.0/test/success/traditional-encryption-and-compression/000077500000000000000000000000001521126516100251125ustar00rootroot00000000000000yauzl-3.4.0/test/success/traditional-encryption-and-compression/a.bin000066400000000000000000000000271521126516100260230ustar00rootroot00000000000000c.,"s IX}Y`yauzl-3.4.0/test/success/traditional-encryption-and-compression_deprecated.zip000066400000000000000000000003071521126516100300160ustar00rootroot00000000000000PK J a.binUT iXiXux c.,"s IX}Y`PK PK J a.binUTiXux PKKfyauzl-3.4.0/test/success/traditional-encryption-and-compression_deprecated/000077500000000000000000000000001521126516100272725ustar00rootroot00000000000000yauzl-3.4.0/test/success/traditional-encryption-and-compression_deprecated/a.bin000066400000000000000000000000271521126516100302030ustar00rootroot00000000000000c.,"s IX}Y`yauzl-3.4.0/test/success/traditional-encryption.zip000066400000000000000000000003021521126516100225320ustar00rootroot00000000000000PK J 0:6a.txtUT :XEXux (=0X&]b\PK 0:6PK J 0:6a.txtUT:Xux PKKayauzl-3.4.0/test/success/traditional-encryption/000077500000000000000000000000001521126516100220135ustar00rootroot00000000000000yauzl-3.4.0/test/success/traditional-encryption/a.txt000066400000000000000000000000221521126516100227660ustar00rootroot00000000000000(=0X&]b\yauzl-3.4.0/test/success/traditional-encryption_deprecated.zip000066400000000000000000000003021521126516100247120ustar00rootroot00000000000000PK J 0:6a.txtUT :XEXux (=0X&]b\PK 0:6PK J 0:6a.txtUT:Xux PKKayauzl-3.4.0/test/success/traditional-encryption_deprecated/000077500000000000000000000000001521126516100241735ustar00rootroot00000000000000yauzl-3.4.0/test/success/traditional-encryption_deprecated/a.txt000066400000000000000000000000221521126516100251460ustar00rootroot00000000000000(=0X&]b\yauzl-3.4.0/test/success/unicode-path-extra-field.zip000066400000000000000000000003411521126516100226150ustar00rootroot00000000000000PK-%H up七个房间.txtPKPK?-%H6 upupupup七个房间.txtPKtWyauzl-3.4.0/test/success/unicode-path-extra-field/000077500000000000000000000000001521126516100220735ustar00rootroot00000000000000yauzl-3.4.0/test/success/unicode-path-extra-field/qi ge fangjian.txt000066400000000000000000000000001521126516100253450ustar00rootroot00000000000000yauzl-3.4.0/test/success/unicode.zip000066400000000000000000000017641521126516100174730ustar00rootroot00000000000000PK z ETurmion Kätilöt/UT SSux PK E ETurmion Kätilöt/Hoitovirhe/UT SSux PK  E+Turmion Kätilöt/Hoitovirhe/Rautaketju.mp3UT S8FSux PK  ETurmion Kätilöt/Pirun nyrkki/UT 0S1Sux PK  E6Turmion Kätilöt/Pirun nyrkki/Mistä veri pakenee.mp3UT S:FSux PK z EATurmion Kätilöt/UTSux PK E EALTurmion Kätilöt/Hoitovirhe/UTSux PK  E+Turmion Kätilöt/Hoitovirhe/Rautaketju.mp3UTSux PK  EATurmion Kätilöt/Pirun nyrkki/UT0Sux PK  E6aTurmion Kätilöt/Pirun nyrkki/Mistä veri pakenee.mp3UTSux PK yauzl-3.4.0/test/success/unicode/000077500000000000000000000000001521126516100167375ustar00rootroot00000000000000yauzl-3.4.0/test/success/unicode/Turmion Katilot/000077500000000000000000000000001521126516100217645ustar00rootroot00000000000000yauzl-3.4.0/test/success/unicode/Turmion Katilot/Hoitovirhe/000077500000000000000000000000001521126516100241045ustar00rootroot00000000000000yauzl-3.4.0/test/success/unicode/Turmion Katilot/Hoitovirhe/Rautaketju.mp3000066400000000000000000000000001521126516100266320ustar00rootroot00000000000000yauzl-3.4.0/test/success/unicode/Turmion Katilot/Pirun nyrkki/000077500000000000000000000000001521126516100243515ustar00rootroot00000000000000yauzl-3.4.0/test/success/unicode/Turmion Katilot/Pirun nyrkki/Mista veri pakenee.mp3000066400000000000000000000000001521126516100303540ustar00rootroot00000000000000yauzl-3.4.0/test/success/unix-epoch.zip000066400000000000000000000002621521126516100201140ustar00rootroot00000000000000PK !unix-epoch.txtUT &gux dPK !unix-epoch.txtUTux dPKTHyauzl-3.4.0/test/success/unix-epoch/000077500000000000000000000000001521126516100173705ustar00rootroot00000000000000yauzl-3.4.0/test/success/unix-epoch/unix-epoch.txt000066400000000000000000000000001521126516100221760ustar00rootroot00000000000000yauzl-3.4.0/test/success/windows-7-zip.zip000077500000000000000000000004241521126516100204760ustar00rootroot00000000000000PK KEQVa.txtasdf PK KEb.txtbsdf PK? KEQV$ a.txt >l>l>lPK? KE$ (b.txt mmmPKPyauzl-3.4.0/test/success/windows-7-zip/000077500000000000000000000000001521126516100177475ustar00rootroot00000000000000yauzl-3.4.0/test/success/windows-7-zip/a.txt000066400000000000000000000000051521126516100207230ustar00rootroot00000000000000asdf yauzl-3.4.0/test/success/windows-7-zip/b.txt000066400000000000000000000000051521126516100207240ustar00rootroot00000000000000bsdf yauzl-3.4.0/test/success/windows-compressed-folder.zip000077500000000000000000000003141521126516100231430ustar00rootroot00000000000000PKKEQVa.txtasdf PKKEb.txtbsdf PKKEQV a.txtPKKE (b.txtPKfPyauzl-3.4.0/test/success/windows-compressed-folder/000077500000000000000000000000001521126516100224165ustar00rootroot00000000000000yauzl-3.4.0/test/success/windows-compressed-folder/a.txt000066400000000000000000000000051521126516100233720ustar00rootroot00000000000000asdf yauzl-3.4.0/test/success/windows-compressed-folder/b.txt000066400000000000000000000000051521126516100233730ustar00rootroot00000000000000bsdf yauzl-3.4.0/test/success/zip64.zip000066400000000000000000000006201521126516100170070ustar00rootroot00000000000000PK-} I test1.txtKPK!esPK-} I test2.txtKJ,PKvPK--} I!es  test1.txtPK--} Iv  Dtest2.txtDPK,--PK.PKyauzl-3.4.0/test/success/zip64/000077500000000000000000000000001521126516100162655ustar00rootroot00000000000000yauzl-3.4.0/test/success/zip64/test1.txt000066400000000000000000000000031521126516100200570ustar00rootroot00000000000000fooyauzl-3.4.0/test/success/zip64/test2.txt000066400000000000000000000000031521126516100200600ustar00rootroot00000000000000baryauzl-3.4.0/test/test.js000066400000000000000000000545001521126516100151620ustar00rootroot00000000000000var yauzl = require("../"); var zip64 = require("./zip64"); var rangeTest = require("./range-test"); var errorsTest = require("./errors"); var fs = require("fs"); var path = require("path"); var Pend = require("pend"); var util = require("util"); var child_process = require("child_process"); var Readable = require("stream").Readable; var Writable = require("stream").Writable; if (require("../crc32")(Buffer.from("hello")) === 907060870) { console.log("crc32: pass"); } else { throw new Error("crc32 wrong"); } // This is a month before I made the example zip files and their content files, // so this timestamp will be earlier than all the ones stored in these test zip files unless otherwise noted. var earliestTimestamp = new Date(2014, 7, 18, 0, 0, 0, 0); if (Date.now() / 1000 >= 2147483648) throw new Error("The year is 2038. The Epochalypse is uppon us. Signed 32-bit POSIX timestamps have collapsed. TODO: fix."); var pend = new Pend(); // 1 thing at a time for better determinism/reproducibility pend.max = 1; var args = process.argv.slice(2); function shouldDoTest(testPath) { if (args.length === 0) return true; return args.indexOf(testPath) !== -1; } var openFunctions = [ function(zipfilePath, testId, options, callback) { yauzl.open(zipfilePath, options, callback); }, function(zipfilePath, testId, options, callback) { yauzl.fromBuffer(fs.readFileSync(zipfilePath), options, callback); }, function(zipfilePath, testId, options, callback) { openWithRandomAccess(zipfilePath, options, true, testId, callback); }, function(zipfilePath, testId, options, callback) { openWithRandomAccess(zipfilePath, options, false, testId, callback); }, ]; var openFunctionNames = [ "fd", "buffer", "randomAccess", "minimalRandomAccess", ]; // success tests listZipFiles([path.join(__dirname, "success"), path.join(__dirname, "wrong-entry-sizes")]).forEach(function(zipfilePath) { if (!shouldDoTest(zipfilePath)) return; var optionConfigurations = [ // you can find more options coverage in the failure tests. {lazyEntries: true}, {lazyEntries: true, decodeStrings: false}, ]; if (/\/wrong-entry-sizes\//.test(zipfilePath)) { optionConfigurations.forEach(function(options) { options.validateEntrySizes = false; }); } openFunctions.forEach(function(openFunction, i) { optionConfigurations.forEach(function(options, j) { var testId = zipfilePath + "(" + openFunctionNames[i] + "," + j + "): "; var expectedPathPrefix = zipfilePath.replace(/\.zip$/, ""); var expectedArchiveContents = {}; var DIRECTORY = 1; // not a string recursiveRead("."); function recursiveRead(name) { // windows support? whatever. var name = name.replace(/\\/g, "/"); var key = addUnicodeSupport(name); var realPath = path.join(expectedPathPrefix, name); if (fs.statSync(realPath).isFile()) { switch (path.basename(name)) { case ".git_please_make_this_directory": // ignore break; case ".dont_expect_an_empty_dir_entry_for_this_dir": delete expectedArchiveContents[path.dirname(name)]; break; default: // normal file expectedArchiveContents[key] = fs.readFileSync(realPath); break; } } else { if (name !== ".") expectedArchiveContents[key] = DIRECTORY; fs.readdirSync(realPath).forEach(function(child) { recursiveRead(path.join(name, child)); }); if (name === "a/b" && path.basename(zipfilePath) === "everything.zip") { // Insert 1000 expected files here that we don't want to waste git's time with. const emptyBuffer = Buffer.from([]); for (let i = 0; i < 1000; i++) { expectedArchiveContents["a/b/" + i.toString().padStart(3, "0")] = emptyBuffer; } } } } pend.go(function(zipfileCallback) { openFunction(zipfilePath, testId, options, function(err, zipfile) { if (err) throw err; zipfile.readEntry(); zipfile.on("entry", function(entry) { var fileName = entry.fileName; var fileComment = entry.fileComment; if (options.decodeStrings === false) { if (fileName.constructor !== Buffer) throw new Error(testId + "expected fileName to be a Buffer"); fileName = manuallyDecodeFileName(fileName); fileComment = manuallyDecodeFileName(fileComment); } if (fileComment !== "") throw new Error(testId + "expected empty fileComment"); var messagePrefix = testId + fileName + ": "; var timestamp = entry.getLastModDate(); if (fileName === "unix-epoch.txt") { if (timestamp.getTime() !== 0) throw new Error(messagePrefix + "expected timestamp to be 0. found: " + timestamp); var dosTimestamp = entry.getLastModDate({forceDosFormat:true}); if (dosTimestamp.getTime() === 0) throw new Error(messagePrefix + "DOS timestamp can't encode this time: " + dosTimestamp); var dosTimestampUTC = entry.getLastModDate({forceDosFormat:true, timezone: "UTC"}); // This test is only meaningful when the system's local UTC offset is not 0. if (dosTimestamp - dosTimestampUTC !== dosTimestamp.getTimezoneOffset() * 60 * 1000) { throw new Error(messagePrefix + "expected UTC timezone to be different by the current timezone offset. " + "local: " + dosTimestamp + ", UTC: " + dosTimestampUTC ); } } else { if (timestamp < earliestTimestamp) throw new Error(messagePrefix + "timestamp too early: " + timestamp); if (timestamp > new Date()) throw new Error(messagePrefix + "timestamp in the future: " + timestamp); } var fileNameKey = fileName.replace(/\/$/, ""); var expectedContents = expectedArchiveContents[fileNameKey]; if (expectedContents == null) { throw new Error(messagePrefix + "not supposed to exist"); } delete expectedArchiveContents[fileNameKey]; if (fileName !== fileNameKey) { // directory console.log(messagePrefix + "pass"); zipfile.readEntry(); } else { var isEncrypted = entry.isEncrypted(); var isCompressed = entry.isCompressed(); if (/traditional-encryption/.test(zipfilePath) !== isEncrypted) { throw new Error("expected traditional encryption in the traditional encryption test cases"); if (/traditional-encryption-and-compression/.test(zipfilePath) !== isCompressed) { throw new Error("expected traditional encryption and compression in the traditional encryption and compression test case"); } } if (/traditional-encryption/.test(zipfilePath)) { if (entry.canDecodeFileData()) throw new Error(messagePrefix + "supposed to be unable to decode this"); if (/deprecated/.test(zipfilePath)) { // Deprecated style. zipfile.openReadStream(entry, { decrypt: false, decompress: isCompressed ? false : null, }, onReadStream); } else { // New style. zipfile.openReadStream(entry, { decodeFileData: false, }, onReadStream); } } else if (/bogus-compression-method/.test(zipfilePath)) { if (entry.canDecodeFileData()) throw new Error(messagePrefix + "supposed to be unable to decode this"); zipfile.openReadStream(entry, { decodeFileData: false, }, onReadStream); } else { if (!entry.canDecodeFileData()) throw new Error(messagePrefix + "supposed to be able to decode this"); zipfile.openReadStream(entry, onReadStream); } function onReadStream(err, readStream) { if (err) throw err; var buffers = []; readStream.on("data", function(data) { buffers.push(data); }); readStream.on("end", function() { var actualContents = Buffer.concat(buffers); // uh. there's no buffer equality check? var equal = actualContents.toString("binary") === expectedContents.toString("binary"); if (!equal) { throw new Error(messagePrefix + "wrong contents"); } if (/^a\/b\/\d{3}$/.test(fileName)) { // There are 1000 of these. if (fileName === "a/b/000") { console.log(messagePrefix + "pass (and not printing for the next 999)"); } } else { console.log(messagePrefix + "pass"); } zipfile.readEntry(); }); readStream.on("error", function(err) { console.log(testId + "fail:"); throw err; }); } } }); zipfile.on("end", function() { for (var fileName in expectedArchiveContents) { throw new Error(testId + fileName + ": missing file"); } console.log(testId + "pass"); zipfileCallback(); }); zipfile.on("close", function() { console.log(testId + "closed"); }); }); }); }); }); }); // failure tests listZipFiles([path.join(__dirname, "failure")]).forEach(function(zipfilePath) { if (!shouldDoTest(zipfilePath)) return; var expectedErrorMessage = path.basename(zipfilePath).replace(/(_\d+)?\.zip$/, ""); openFunctions.forEach(function(openFunction, i) { var testId = zipfilePath + "(" + openFunctionNames[i] + "): "; var failedYet = false; var emittedError = false; pend.go(function(cb) { var operationsInProgress = 0; var options = null; if (/invalid characters in fileName/.test(zipfilePath)) { // this error can only happen when you specify an option options = {strictFileNames: true}; } openFunction(zipfilePath, testId, options, onZipFile); function onZipFile(err, zipfile) { if (err) return checkErrorMessage(err); zipfile.on("error", function(err) { noEventsAllowedAfterError(); emittedError = true; checkErrorMessage(err); }); zipfile.on("entry", function(entry) { noEventsAllowedAfterError(); // let's also try to read directories, cuz whatever. operationsInProgress += 1; zipfile.openReadStream(entry, function(err, stream) { if (err) return checkErrorMessage(err); stream.on("error", function(err) { checkErrorMessage(err); }); stream.on("data", function(data) { // ignore }); stream.on("end", function() { doneWithSomething(); }); }); }); operationsInProgress += 1; zipfile.on("end", function() { noEventsAllowedAfterError(); doneWithSomething(); }); function doneWithSomething() { operationsInProgress -= 1; if (operationsInProgress !== 0) return; if (!failedYet) { throw new Error(testId + "expected failure"); } } } function checkErrorMessage(err) { var actualMessage = err.message.replace(/[^0-9A-Za-z-]+/g, " ").trimRight(); // eCryptfs limits file names to 143 bytes. (All file names are ascii.) actualMessage = actualMessage.slice(0, 143 - ".zip".length); if (actualMessage !== expectedErrorMessage) { if (i !== 0) { // The error messages are tuned for the common case. // Sometimes other open functions give slightly different error messages, and that's ok, // as long as we're still getting some error. } else { throw new Error(testId + "wrong error message: " + actualMessage); } } console.log(testId + "pass"); failedYet = true; operationsInProgress = -Infinity; cb(); } function noEventsAllowedAfterError() { if (emittedError) throw new Error(testId + "events emitted after error event"); } }); }); }); // fromRandomAccessReader with errors pend.go(function(cb) { util.inherits(TestRandomAccessReader, yauzl.RandomAccessReader); function TestRandomAccessReader() { yauzl.RandomAccessReader.call(this); } TestRandomAccessReader.prototype._readStreamForRange = function(start, end) { var brokenator = new Readable(); brokenator._read = function(size) { brokenator.emit("error", new Error("all reads fail")); }; return brokenator; }; var reader = new TestRandomAccessReader(); yauzl.fromRandomAccessReader(reader, 0x1000, function(err, zipfile) { if (err.message === "all reads fail") { console.log("fromRandomAccessReader with errors: pass"); cb(); } else { throw err; } }); }); // read some entries, then close. pend.go(function(cb) { var prefix = "read some entries then close: "; // this zip file should have at least 3 entries in it yauzl.open(path.join(__dirname, "success/unicode.zip"), {lazyEntries: true}, function(err, zipfile) { if (err) throw err; var entryCount = 0; zipfile.readEntry(); zipfile.on("entry", function(entry) { entryCount += 1; console.log(prefix + "entryCount: " + entryCount); if (entryCount < 3) { zipfile.readEntry(); } else if (entryCount === 3) { zipfile.close(); console.log(prefix + "close()"); } else { throw new Error(prefix + "read too many entries"); } }); zipfile.on("close", function() { console.log(prefix + "closed"); if (entryCount === 3) { console.log(prefix + "pass"); cb(); } else { throw new Error(prefix + "not enough entries read before closed"); } }); zipfile.on("end", function() { throw new Error(prefix + "we weren't supposed to get to the end"); }); zipfile.on("error", function(err) { throw err; }); }); }); // Abort open read stream with several combinations of stream pipelines. // The destroy logic depends on whether there's an inflater, a byte counter, etc. ["big-compression.zip", "big-uncompressed.zip"].forEach(input => { const inputPath = path.join(__dirname, "success", input); [{}, {validateEntrySizes: false}].forEach((options, i) => { pend.go(function(cb) { yauzl.open(inputPath, {lazyEntries: true, ...options}, function(err, zipfile) { if (err) throw err; const prefix = `destroy: ${input}: open(${i}): `; testTheFile(prefix, zipfile, true, cb); }); }); pend.go(function(cb) { yauzl.fromBuffer(fs.readFileSync(inputPath), {lazyEntries: true, ...options}, function(err, zipfile) { if (err) throw err; const prefix = `destroy: ${input}: fromBuffer(${i}): `; testTheFile(prefix, zipfile, false, cb); }); }); }); function testTheFile(prefix, zipfile, canClose, cb) { console.log(prefix + "start"); var doneWithStream = false; zipfile.readEntry(); zipfile.on("entry", function(entry) { zipfile.openReadStream(entry, function(err, readStream) { var writer = new Writable(); var bytesSeen = 0; writer._write = function(chunk, encoding, callback) { bytesSeen += chunk.length; if (bytesSeen < entry.uncompressedSize / 10) { // keep piping a bit longer callback(); } else { // alright, i've seen enough. doneWithStream = true; console.log(prefix + "destroy()"); readStream.unpipe(writer); readStream.destroy(); // now keep trying to use the fd zipfile.readEntry(); } }; readStream.pipe(writer); }); }); zipfile.on("end", function() { console.log(prefix + "end"); if (!canClose) { // fromBuffer never emits "close". cleanup(); } }); zipfile.on("close", function() { console.log(prefix + "closed"); cleanup(); }); function cleanup() { if (doneWithStream) { console.log(prefix + "pass"); cb(); } else { throw new Error(prefix + "closed prematurely"); } } zipfile.on("error", function(err) { throw err; }); } }); // zip64 pend.go(zip64.runTest); // openReadStream with range pend.go(rangeTest.runTest); // Test error propagation. pend.go(errorsTest.runTest); // Make sure the examples run without crashing. pend.go(function(cb) { var examplesDir = path.join(__dirname, "../examples"); var zipfiles = listZipFiles([path.join(__dirname, "success")]); function canDecodeFileData(filePath) { return !/traditional-encryption|bogus-compression-method/.exec(path.basename(filePath)); } var zipfilesCanDecodeFileData = zipfiles.filter(canDecodeFileData); var tmpDir = path.join(__dirname, ".tmp"); if (typeof fs.rmSync === "function") fs.rmSync(tmpDir, {recursive: true, force: true}); var parametersToTest = { "examples/compareCentralAndLocalHeaders.js": zipfiles, "examples/dump.js": zipfiles, "examples/promises.js": zipfiles, "examples/unzip.js": zipfilesCanDecodeFileData, }; if (JSON.stringify(fs.readdirSync(examplesDir).sort().map(s => `examples/${s}`)) !== JSON.stringify(Object.keys(parametersToTest).sort())) throw new Error("unexpected examples/ directory listing"); // Test this one too, but it's not an example. parametersToTest["test/forAwait.js"] = zipfilesCanDecodeFileData for (var script in parametersToTest) { var args = parametersToTest[script]; if (script === "examples/unzip.js" && typeof fs.rmSync !== "function") { console.log("WARNING: skipping examples/unzip.js tests for node <14"); continue; } args.forEach(function(arg) { var args = [path.resolve(script)]; var options = { stdio: ["ignore", "ignore", "inherit"], timeout: 10_000, }; var testId; if (arg != null) { args.push(path.resolve(arg)); testId = `examples/${script} ${path.basename(arg)}: `; } else { testId = `examples/${script}: `; } // Handle special cases. if (script === "examples/dump.js" && !canDecodeFileData(arg)) { args.push("--no-contents"); } if (script === "examples/promises.js" && !canDecodeFileData(arg)) { args.push("--no-readStream"); } if (script === "examples/unzip.js") { // Quaranetine this in a temp directory. fs.mkdirSync(tmpDir); options.cwd = tmpDir; } process.stdout.write(testId); var {status, error} = child_process.spawnSync("node", args, options); if (status) error = new Error("child process return exit code " + status); if (error) throw error; if (script === "examples/unzip.js") { // Quaranetine this in a temp directory. fs.rmSync(tmpDir, {recursive: true, force: true}); } process.stdout.write("pass\n"); }); } cb(); }); var done = false; pend.wait(function() { console.log("all done"); done = true; }); process.on("exit", function(code) { if (code === 0 && !done) { throw new Error("premature exit. probably means an event never got fired."); } }); function listZipFiles(dirList) { var zipfilePaths = []; dirList.forEach(function(dir) { fs.readdirSync(dir).filter(function(filepath) { return /\.zip$/.exec(filepath); }).forEach(function(name) { zipfilePaths.push(path.relative(".", path.join(dir, name))); }); }); zipfilePaths.sort(); return zipfilePaths; } function addUnicodeSupport(name) { // reading and writing unicode filenames on mac is broken. // we keep all our test data ascii, and then swap in the real names here. // see https://github.com/thejoshwolfe/yauzl/issues/10 name = name.replace(/Turmion Katilot/g, "Turmion Kätilöt"); name = name.replace(/Mista veri pakenee/g, "Mistä veri pakenee"); name = name.replace(/qi ge fangjian/g, "七个房间"); return name; } function manuallyDecodeFileName(fileName) { // file names in this test suite are always utf8 compatible. fileName = fileName.toString("utf8"); fileName = fileName.replace("\\", "/"); if (fileName === "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f") { // we're not doing the unicode path extra field decoding outside of yauzl. // just hardcode this answer. fileName = "七个房间.txt"; } return fileName; } function openWithRandomAccess(zipfilePath, options, implementRead, testId, callback) { util.inherits(InefficientRandomAccessReader, yauzl.RandomAccessReader); function InefficientRandomAccessReader() { yauzl.RandomAccessReader.call(this); } InefficientRandomAccessReader.prototype._readStreamForRange = function(start, end) { return fs.createReadStream(zipfilePath, {start: start, end: end - 1}); }; if (implementRead) { InefficientRandomAccessReader.prototype.read = function(buffer, offset, length, position, callback) { fs.open(zipfilePath, "r", function(err, fd) { if (err) return callback(err); fs.read(fd, buffer, offset, length, position, function(err, bytesRead) { if (bytesRead < length) return callback(new Error("unexpected EOF")); fs.close(fd, function(err) { if (err) return callback(err); callback(); }); }); }); }; } InefficientRandomAccessReader.prototype.close = function(cb) { console.log(testId + "close hook"); yauzl.RandomAccessReader.prototype.close.call(this, cb); }; fs.stat(zipfilePath, function(err, stats) { if (err) return callback(err); var reader = new InefficientRandomAccessReader(); yauzl.fromRandomAccessReader(reader, stats.size, options, function(err, zipfile) { if (err) return callback(err); callback(null, zipfile); }); }); } yauzl-3.4.0/test/wrong-entry-sizes/000077500000000000000000000000001521126516100172675ustar00rootroot00000000000000yauzl-3.4.0/test/wrong-entry-sizes/wrong-entry-sizes.zip000066400000000000000000000005001521126516100234340ustar00rootroot00000000000000PKrJa.txt%pPK'PKrJb.txtPK~.ELPKrJc/PK?rJ0a.txtPK?rJ~.E:b.txtPK?rJAtc/PKyauzl-3.4.0/test/wrong-entry-sizes/wrong-entry-sizes/000077500000000000000000000000001521126516100227155ustar00rootroot00000000000000yauzl-3.4.0/test/wrong-entry-sizes/wrong-entry-sizes/a.txt000066400000000000000000000000471521126516100236770ustar00rootroot00000000000000====================================== yauzl-3.4.0/test/wrong-entry-sizes/wrong-entry-sizes/b.txt000066400000000000000000000001141521126516100236730ustar00rootroot00000000000000=========================================================================== yauzl-3.4.0/test/wrong-entry-sizes/wrong-entry-sizes/c/000077500000000000000000000000001521126516100231375ustar00rootroot00000000000000yauzl-3.4.0/test/wrong-entry-sizes/wrong-entry-sizes/c/.git_please_make_this_directory000066400000000000000000000000001521126516100313520ustar00rootroot00000000000000yauzl-3.4.0/test/zip64.js000066400000000000000000000230551521126516100151600ustar00rootroot00000000000000var fs = require("fs"); var path = require("path"); var yauzl = require("../"); var util = require("util"); var Readable = require("stream").Readable; var Writable = require("stream").Writable; var BufferList = require("bl"); exports.runTest = runTest; function usage() { process.stdout.write("" + "zip64.js usage:\n" + " (no arguments) run the test\n" + " -d dir/ dump the contents of the expected zip file into the specified directory\n" + " -z in.zip out.zip compress in.zip into out.zip\n" + "\n" + "To recreate the file `zip64.zip_fragment`,\n" + "do the following (from the root directory of this project):\n" + "\n" + "```\n" + "mkdir tmp\n" + "node test/zip64.js -d tmp/\n" + "(cd tmp/ && zip -0 zip64.zip a.txt large.bin b.txt)\n" + "node test/zip64.js -z tmp/zip64.zip test/zip64/zip64.zip_fragment\n" + "rm -rf tmp/\n" + "```\n" + ""); process.exit(1); } function cli() { var arg1 = process.argv[2]; var arg2 = process.argv[3]; var arg3 = process.argv[4]; if (arg1 == null) { runTest(); return; } if (/^--?h/.test(arg1)) usage(); if (arg1 === "-d") { if (arg2 == null) usage(); dumpExpectedContents(arg2); return; } if (arg1 === "-z") { if (arg2 == null) usage(); if (arg3 == null) usage(); compressFile(arg2, arg3); return; } usage(); } function dumpExpectedContents(outputDir) { var readStream = newLargeBinContentsProducer(); readStream.pipe(fs.createWriteStream(path.join(outputDir, "large.bin"))); readStream.on("progress", function(numerator, denominator) { process.stderr.write("\r" + numerator + "/" + denominator + " " + ((numerator / denominator * 100) | 0) + "%"); if (numerator === denominator) process.stderr.write("\n"); }); fs.writeFileSync(path.join(outputDir, "a.txt"), "hello a\n"); fs.writeFileSync(path.join(outputDir, "b.txt"), "hello b\n"); } var largeBinLength = 8000000000; function newLargeBinContentsProducer() { // emits the fibonacci sequence: // 0, 1, 1, 2, 3, 5, 8, 13, ... // with each entry encoded in a UInt32BE. // arithmetic overflow will happen eventually, resulting in wrap around. // as a consequence of limited precision, this sequence repeats itself after 6442450944 entires. // however, we only require 2000000000 entires, so it's good enough. var readStream = new Readable(); var prev0 = -1; var prev1 = 1; var byteCount = 0; readStream._read = function(size) { while (true) { if (byteCount >= largeBinLength) { readStream.push(null); return; } var bufferSize = Math.min(0x800000, largeBinLength - byteCount); var buffer = Buffer.allocUnsafe(bufferSize); for (var i = 0; i < bufferSize; i += 4) { var n = ((prev0 + prev1) & 0xffffffff) >>> 0; prev0 = prev1; prev1 = n; byteCount += 4; buffer.writeUInt32BE(n, i, true); } readStream.emit("progress", byteCount, largeBinLength); if (!readStream.push(buffer)) return; } }; readStream.destroy = function() {}; return readStream; } // this is just some bytes so we can identify it. var prefixLength = 0x100; function getPrefixOfStream(stream, cb) { var prefixBuffer = Buffer.allocUnsafe(prefixLength); var writer = new Writable(); writer._write = function(chunk, encoding, callback) { chunk.copy(prefixBuffer, 0, 0, prefixLength); stream.unpipe(writer); cb(prefixBuffer); }; stream.pipe(writer); } function getPrefixOfLargeBinContents(cb) { getPrefixOfStream(newLargeBinContentsProducer(), cb); } function compressFile(inputPath, outputPath) { getPrefixOfLargeBinContents(function(prefixBuffer) { findPrefixInPath(prefixBuffer, function(largeBinContentsOffset) { writeCompressedFile(largeBinContentsOffset); }); }); function findPrefixInPath(prefixBuffer, cb) { var previewLength = 0x1000; fs.createReadStream(inputPath, { start: 0, end: previewLength + prefixLength - 1, }).pipe(BufferList(function(err, data) { if (err) throw err; for (var i = 0; i < previewLength; i++) { if (buffersEqual(data.slice(i, prefixLength), prefixBuffer)) { return cb(i); } } throw new Error("can't find large.bin contents"); })); } function writeCompressedFile(largeBinContentsOffset) { var writeStream = fs.createWriteStream(outputPath); var headerBuffer = Buffer.allocUnsafe(4); headerBuffer.writeUInt32BE(largeBinContentsOffset, 0); writeStream.write(headerBuffer); var firstReader = fs.createReadStream(inputPath, { start: 0, end: largeBinContentsOffset - 1, }); firstReader.pipe(writeStream, {end: false}); firstReader.on("end", function() { var secondReader = fs.createReadStream(inputPath, { start: largeBinContentsOffset + largeBinLength, }); secondReader.pipe(writeStream); }); } } var logPrefix = "test/zip64: "; function runTest(cb) { if (cb == null) cb = function() {}; makeRandomAccessReader(function(reader, size) { yauzl.fromRandomAccessReader(reader, size, function(err, zipfile) { if (err) throw err; var entryIndex = 0; zipfile.on("entry", function(entry) { var expectedContents; if (entryIndex === 0) { if (entry.fileName !== "a.txt") throw new Error(logPrefix + "expected 'a.txt'. got '" + entry.fileName + "'."); expectedContents = "hello a\n"; } else if (entryIndex === 1) { if (entry.fileName !== "large.bin") throw new Error(logPrefix + "expected 'large.bin'. got '" + entry.fileName + "'."); expectedContents = null; // special case } else if (entryIndex === 2) { if (entry.fileName !== "b.txt") throw new Error(logPrefix + "expected 'b.txt'. got '" + entry.fileName + "'."); expectedContents = "hello b\n"; } else { throw new Error(logPrefix + "too many entries"); } entryIndex += 1; zipfile.openReadStream(entry, function(err, readStream) { if (err) throw err; if (expectedContents != null) { readStream.pipe(BufferList(function(err, data) { if (data.toString() !== expectedContents) throw new Error(logPrefix + "expected contents:\n" + expectedContents + "\ngot:\n" + data.toString() + "\n"); console.log(logPrefix + entry.fileName + ": pass"); })); } else { // make sure this is the big thing getPrefixOfLargeBinContents(function(expectedPrefixBuffer) { getPrefixOfStream(readStream, function(actualPrefixBuffer) { readStream.destroy(); if (buffersEqual(expectedPrefixBuffer, actualPrefixBuffer)) { console.log(logPrefix + entry.fileName + ": pass"); } else { throw new Error(logPrefix + "large.bin contents read did not return expected stream"); } }); }); } }); }); zipfile.on("close", function() { console.log(logPrefix + "closed"); if (entryIndex === 3) { console.log(logPrefix + "pass"); cb(); } else { throw new Error(logPrefix + "closed prematurely"); } }); }); }); } function makeRandomAccessReader(cb) { var fileName = "zip64/zip64.zip_fragment"; fs.readFile(path.join(__dirname, fileName), function(err, backendContents) { if (err) return callback(err); if (backendContents.length <= 4) throw new Error("unexpected EOF"); var largeBinContentsOffset = backendContents.readUInt32BE(0) - 4; if (largeBinContentsOffset > backendContents.length) throw new Error(".zip_fragment header is malformed"); var largeBinContentsEnd = largeBinContentsOffset + largeBinLength; var firstRead = true; var pretendSize = backendContents.length + largeBinLength - 4; util.inherits(InflatingRandomAccessReader, yauzl.RandomAccessReader); function InflatingRandomAccessReader() { yauzl.RandomAccessReader.call(this); } InflatingRandomAccessReader.prototype._readStreamForRange = function(start, end) { var thisIsTheFirstRead = firstRead; firstRead = false; var result = new BufferList(); if (end <= largeBinContentsOffset) { result.append(backendContents.slice(start + 4, end + 4)); } else if (start >= largeBinContentsOffset + largeBinLength) { result.append(backendContents.slice(start - largeBinLength + 4, end - largeBinLength + 4)); } else if (start === largeBinContentsOffset && end === largeBinContentsEnd) { return newLargeBinContentsProducer(); } else if (thisIsTheFirstRead && start > largeBinContentsOffset && end === pretendSize) { // yauzl's first move is to cast a large net to try to find the EOCDR. // yauzl's only going to care about the end of this data, so fill in the gaps with dummy data. var dummyTrash = Buffer.allocUnsafe(largeBinContentsEnd - start); result.append(dummyTrash); result.append(backendContents.slice(largeBinContentsOffset + 4)); } else { throw new Error("_readStreamForRange("+start+", "+end+") misaligned to range ["+largeBinContentsOffset+", "+largeBinContentsEnd+"]"); } result.destroy = function() {}; return result; }; var reader = new InflatingRandomAccessReader(); cb(reader, pretendSize); }); } function buffersEqual(buf1, buf2) { for (var i = 0; i < buf1.length; i++) { if (buf1[i] !== buf2[i]) return false; } return true; } if (require.main === module) cli(); yauzl-3.4.0/test/zip64/000077500000000000000000000000001521126516100146155ustar00rootroot00000000000000yauzl-3.4.0/test/zip64/zip64.zip_fragment000066400000000000000000000011201521126516100201720ustar00rootroot00000000000000PK WuG@m[a.txtUT qVqVux hello a PK-uG9's 0large.binUT 5qVqVux PPPK WuG@pb.txtUT qVqVux hello b PK WuG@m[a.txtUTqVux PK-uG9's ,Glarge.binUT5qVux PPPK WuG@p$b.txtUTqVux PPK,-PPKQPK