mirror of
https://github.com/0x5eal/rbxts-pako.git
synced 2025-04-04 19:01:00 +01:00
Updated docs & inflate wrapper
This commit is contained in:
Vitaly Puzrin
parent
2d09ff455d
commit
eb234788e0
2 changed files with 298 additions and 63 deletions
|
|
@ -65,6 +65,23 @@ function sliceBuf(buf, size) {
|
|||
* - `chunkSize` - size of generated data chunks (16K by default)
|
||||
* - `raw` (boolean) - do raw deflate
|
||||
* - `gzip` (boolean) - create gzip wrapper
|
||||
*
|
||||
* ##### Example:
|
||||
*
|
||||
* ```javascript
|
||||
* var pako = require('pako')
|
||||
* , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])
|
||||
* , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);
|
||||
*
|
||||
* var deflate = new pako.Deflate({ level: 3});
|
||||
*
|
||||
* deflate.push(chunk1, false);
|
||||
* deflate.push(chunk2, true); // true -> last chunk
|
||||
*
|
||||
* if (deflate.err) { throw new Error(deflate.err); }
|
||||
*
|
||||
* console.log(deflate.result);
|
||||
* ```
|
||||
**/
|
||||
var Deflate = function(options) {
|
||||
|
||||
|
|
@ -118,6 +135,20 @@ var Deflate = function(options) {
|
|||
* [[Deflate#onEnd]].
|
||||
*
|
||||
* On fail call [[Deflate#onEnd]] with error code and return false.
|
||||
*
|
||||
* We strongly recommend to use `Uint8Array` on input for best speed (output
|
||||
* format is detected automatically). Also, don't skip last param and always
|
||||
* use the same type in your code (boolean or number). That will improve JS speed.
|
||||
*
|
||||
* For regular `Array`-s make sure all elements are [0..255].
|
||||
*
|
||||
* ##### Example
|
||||
*
|
||||
* ```javascript
|
||||
* push(chunk, false); // push one of data chunks
|
||||
* ...
|
||||
* push(chunk, true); // push last chunk
|
||||
* ```
|
||||
**/
|
||||
Deflate.prototype.push = function(data, mode) {
|
||||
var strm = this.strm;
|
||||
|
|
@ -182,9 +213,9 @@ Deflate.prototype.onData = function(chunk) {
|
|||
* - status (Number): deflate status. 0 (Z_OK) on success,
|
||||
* other if not.
|
||||
*
|
||||
* Called once after you tell deflate that input stream complete.
|
||||
* By default - join collected chunks, free memory and fill
|
||||
* `results` / `err` properties.
|
||||
* Called once after you tell deflate that input stream complete
|
||||
* or error happenned. By default - join collected chunks,
|
||||
* free memory and fill `results` / `err` properties.
|
||||
**/
|
||||
Deflate.prototype.onEnd = function(status) {
|
||||
// On success - join
|
||||
|
|
@ -195,7 +226,6 @@ Deflate.prototype.onEnd = function(status) {
|
|||
this.err = status;
|
||||
// TODO: detect message by status, if not set in zstream
|
||||
this.msg = this.strm.msg || msg[status];
|
||||
this.ended = true;
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -215,6 +245,15 @@ Deflate.prototype.onEnd = function(status) {
|
|||
*
|
||||
* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
|
||||
* for more information on these.
|
||||
*
|
||||
* ##### Example:
|
||||
*
|
||||
* ```javascript
|
||||
* var pako = require('pako')
|
||||
* , data = Uint8Array([1,2,3,4,5,6,7,8,9]);
|
||||
*
|
||||
* console.log(pako.deflate(data));
|
||||
* ```
|
||||
**/
|
||||
function deflate(input, options) {
|
||||
var deflator = new Deflate(options);
|
||||
|
|
|
|||
314
lib/inflate.js
314
lib/inflate.js
|
|
@ -1,73 +1,269 @@
|
|||
'use strict';
|
||||
|
||||
//var z_inflate = require('./zlib/inflate');
|
||||
|
||||
var zlib_inflate = require('./zlib/inflate.js');
|
||||
var utils = require('./zlib/utils');
|
||||
var c = require('./zlib/constants');
|
||||
var msg = require('./zlib/messages');
|
||||
var zstream = require('./zlib/zstream');
|
||||
|
||||
// return sliced buffer, trying to avoid new objects creation and mem copy
|
||||
function sliceBuf(buf, size) {
|
||||
if (buf.length === size) { return buf; }
|
||||
|
||||
var Inflate = function(/*options*/) {
|
||||
|
||||
};
|
||||
|
||||
|
||||
Inflate.prototype.push = function(/*data_in*/) {
|
||||
|
||||
};
|
||||
|
||||
Inflate.prototype.finish = function() {
|
||||
|
||||
};
|
||||
|
||||
Inflate.prototype.onData = function(/*data_out*/) {
|
||||
|
||||
};
|
||||
|
||||
Inflate.prototype.onEnd = function(/*error*/) {
|
||||
|
||||
};
|
||||
|
||||
function inflate (input, options) {
|
||||
var result;
|
||||
var chains = [];
|
||||
var inflator = new Inflate(options);
|
||||
|
||||
inflator.onData = function(data_out) {
|
||||
chains.push(data_out);
|
||||
};
|
||||
|
||||
inflator.onEnd = function(error) {
|
||||
var i, l, len, pos, chain;
|
||||
|
||||
if (error) { throw error; }
|
||||
|
||||
// calculate data length
|
||||
len = 0;
|
||||
for (i=0, l=chains.length; i<l; i++) {
|
||||
len += chains[i].length;
|
||||
}
|
||||
|
||||
// join chains
|
||||
result = utils.arrayCreate(len);
|
||||
pos = 0;
|
||||
|
||||
for (i=0, l=chains.length; i<l; i++) {
|
||||
chain = chains[i];
|
||||
len = chain.length;
|
||||
utils.arraySet(result, chain, 0, len, pos);
|
||||
pos += len;
|
||||
}
|
||||
};
|
||||
|
||||
inflator.push(input);
|
||||
|
||||
return result;
|
||||
return utils.typedOk() ? buf.subarray(0, size) : buf.slice(0, size);
|
||||
}
|
||||
|
||||
function inflateRaw (input, options) {
|
||||
/**
|
||||
* class Inflate
|
||||
*
|
||||
* Generic JS-style wrapper for zlib calls. If you don't need
|
||||
* streaming behaviour - use more simple functions: [[inflate]]
|
||||
* and [[inflateRaw]].
|
||||
**/
|
||||
|
||||
/* internal
|
||||
* inflate.chunks -> Array
|
||||
*
|
||||
* Chunks of output data, if [[Inflate#onData]] not overriden.
|
||||
**/
|
||||
|
||||
/**
|
||||
* Inflate.result -> Uint8Array|Array
|
||||
*
|
||||
* Uncompressed result, generated by default [[Inflate#onData]]
|
||||
* and [[Inflate#onEnd]] handlers. Filled after you push last chunk
|
||||
* (call [[Inflate#push]] with `Z_FINISH` / `true` param).
|
||||
**/
|
||||
|
||||
/**
|
||||
* Inflate.err -> Number
|
||||
*
|
||||
* Error code after inflate finished. 0 (Z_OK) on success.
|
||||
* Should be checked if broken data possible.
|
||||
**/
|
||||
|
||||
|
||||
/**
|
||||
* new Inflate(options)
|
||||
* - options (Object): zlib inflate options.
|
||||
*
|
||||
* Creates new inflator instance with specified params. Supported options:
|
||||
*
|
||||
* - `windowBits`
|
||||
*
|
||||
* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
|
||||
* for more information on these.
|
||||
*
|
||||
* Additional options, for internal needs:
|
||||
*
|
||||
* - `chunkSize` - size of generated data chunks (16K by default)
|
||||
* - `raw` (boolean) - do raw inflate
|
||||
*
|
||||
* ##### Example:
|
||||
*
|
||||
* ```javascript
|
||||
* var pako = require('pako')
|
||||
* , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])
|
||||
* , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);
|
||||
*
|
||||
* var inflate = new pako.Inflate({ level: 3});
|
||||
*
|
||||
* inflate.push(chunk1, false);
|
||||
* inflate.push(chunk2, true); // true -> last chunk
|
||||
*
|
||||
* if (inflate.err) { throw new Error(inflate.err); }
|
||||
*
|
||||
* console.log(inflate.result);
|
||||
* ```
|
||||
**/
|
||||
var Inflate = function(options) {
|
||||
|
||||
this.options = utils.assign({
|
||||
chunkSize: 16384,
|
||||
windowBits: 15 + 32
|
||||
}, options || {});
|
||||
|
||||
var opt = this.options;
|
||||
|
||||
if (opt.raw && (opt.windowBits > 0)) {
|
||||
opt.windowBits = -opt.windowBits;
|
||||
}
|
||||
|
||||
this.ended = false; // used to avoid multiple onEnd() calls
|
||||
this.chunks = []; // chunks of compressed data
|
||||
|
||||
this.strm = new zstream();
|
||||
|
||||
var status = zlib_inflate.inflateInit2(
|
||||
this.strm,
|
||||
opt.windowBits
|
||||
);
|
||||
|
||||
if (status !== c.Z_OK) {
|
||||
throw new Error(msg[status]);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Inflate#push(data[, mode]) -> Boolean
|
||||
* - data (Uint8Array|Array): input data
|
||||
* - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.
|
||||
* See constants. Skipped or `false` means Z_NO_FLUSH, `true` meansh Z_FINISH.
|
||||
*
|
||||
* Sends input data to inflate pipe, generating [[Inflate#onData]] calls with
|
||||
* new output chunks. Returns `true` on success. The last data block must have
|
||||
* mode Z_FINISH (or `true`). That flush internal pending buffers and call
|
||||
* [[Inflate#onEnd]].
|
||||
*
|
||||
* On fail call [[Inflate#onEnd]] with error code and return false.
|
||||
*
|
||||
* We strongly recommend to use `Uint8Array` on input for best speed (output
|
||||
* format is detected automatically). Also, don't skip last param and always
|
||||
* use the same type in your code (boolean or number). That will improve JS speed.
|
||||
*
|
||||
* For regular `Array`-s make sure all elements are [0..255].
|
||||
*
|
||||
* ##### Example
|
||||
*
|
||||
* ```javascript
|
||||
* push(chunk, false); // push one of data chunks
|
||||
* ...
|
||||
* push(chunk, true); // push last chunk
|
||||
* ```
|
||||
**/
|
||||
Inflate.prototype.push = function(data, mode) {
|
||||
var strm = this.strm;
|
||||
var chunkSize = this.options.chunkSize;
|
||||
var status, _mode;
|
||||
|
||||
if (this.ended) { return false; }
|
||||
|
||||
_mode = (mode === ~~mode) ? mode : ((mode === true) ? c.Z_FINISH : c.Z_NO_FLUSH);
|
||||
|
||||
strm.next_in = data;
|
||||
strm.next_in_index = 0;
|
||||
strm.avail_in = strm.next_in.length;
|
||||
strm.next_out = utils.arrayCreate(chunkSize);
|
||||
|
||||
do {
|
||||
strm.avail_out = this.options.chunkSize;
|
||||
strm.next_out_index = 0;
|
||||
status = zlib_inflate.inflate(strm, _mode); /* no bad return value */
|
||||
|
||||
if (status !== c.Z_STREAM_END && status !== c.Z_OK) {
|
||||
this.onEnd(status);
|
||||
this.ended = true;
|
||||
return false;
|
||||
}
|
||||
if(strm.next_out_index) {
|
||||
this.onData(sliceBuf(strm.next_out, strm.next_out_index));
|
||||
// Allocate buffer for next chunk, if not last
|
||||
if (strm.avail_in > 0 || strm.avail_out === 0) {
|
||||
strm.next_out = utils.arrayCreate(this.options.chunkSize);
|
||||
}
|
||||
}
|
||||
} while (strm.avail_in > 0 || strm.avail_out === 0);
|
||||
|
||||
// Finalize on the last chunk.
|
||||
if (_mode === c.Z_FINISH) {
|
||||
status = zlib_inflate.inflateEnd(this.strm);
|
||||
this.onEnd(status);
|
||||
this.ended = true;
|
||||
return status === c.Z_OK;
|
||||
}
|
||||
|
||||
return true;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Inflate#onData(chunk) -> Void
|
||||
* - chunk (Uint8Array|Array): ouput data. Type of array depends
|
||||
* on js engine support.
|
||||
*
|
||||
* By default, stores data blocks in `chunks[]` property and glue
|
||||
* those in `onEnd`. Override this handler, if you need another behaviour.
|
||||
**/
|
||||
Inflate.prototype.onData = function(chunk) {
|
||||
this.chunks.push(chunk);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Inflate#onEnd(status) -> Void
|
||||
* - status (Number): inflate status. 0 (Z_OK) on success,
|
||||
* other if not.
|
||||
*
|
||||
* Called once after you tell inflate that input stream complete
|
||||
* or error happenned. By default - join collected chunks,
|
||||
* free memory and fill `results` / `err` properties.
|
||||
**/
|
||||
Inflate.prototype.onEnd = function(status) {
|
||||
// On success - join
|
||||
if (status === c.Z_OK) {
|
||||
this.result = utils.flattenChunks(this.chunks);
|
||||
}
|
||||
this.chunks = [];
|
||||
this.err = status;
|
||||
// TODO: detect message by status, if not set in zstream
|
||||
this.msg = this.strm.msg || msg[status];
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* inflate(data[, options]) -> Uint8Array|Array
|
||||
* - data (Uint8Array|Array): input data to compress.
|
||||
* - options (Object): zlib inflate options.
|
||||
*
|
||||
* Decompress `data` with inflate alrorythm and `options`.
|
||||
*
|
||||
* Supported options are:
|
||||
*
|
||||
* - windowBits
|
||||
*
|
||||
* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
|
||||
* for more information on these.
|
||||
*
|
||||
* ##### Example:
|
||||
*
|
||||
* ```javascript
|
||||
* var pako = require('pako')
|
||||
* , in = Uint8Array([1,2,3,4,5,6,7,8,9])
|
||||
* , out;
|
||||
*
|
||||
* out = pako.inflate(data);
|
||||
* if (out.err) { throw new Error(out.err); }
|
||||
* console.log(pako.inflate(out.result));
|
||||
* ```
|
||||
**/
|
||||
function inflate(input, options) {
|
||||
var inflator = new Inflate(options);
|
||||
|
||||
inflator.push(input, true);
|
||||
|
||||
// That will never happens, if you don't cheat with options :)
|
||||
if (inflator.err) { throw msg[inflator.err]; }
|
||||
|
||||
return inflator.result;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* inflateRaw(data[, options]) -> Uint8Array|Array
|
||||
* - data (Uint8Array|Array): input data to compress.
|
||||
* - options (Object): zlib inflate options.
|
||||
*
|
||||
* The same as [[inflate]], but creates raw data, without wrapper
|
||||
* (header and adler32 crc).
|
||||
**/
|
||||
function inflateRaw(input, options) {
|
||||
options = options || {};
|
||||
options.raw = true;
|
||||
return inflate(input, options);
|
||||
}
|
||||
|
||||
|
||||
exports.Inflate = Inflate;
|
||||
exports.inflate = inflate;
|
||||
exports.inflateRaw = inflateRaw;
|
||||
exports.inflateRaw = inflateRaw;
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue