0x5eal/rbxts-pako
1
0
Fork 0
mirror of https://github.com/0x5eal/rbxts-pako.git synced 2025-04-04 10:50:59 +01:00
Code Issues Projects Releases Packages Wiki Activity

Coding Style & eslint rules update

Browse source
This commit is contained in:
Vitaly Puzrin 2016-02-17 10:05:16 +03:00
parent 7385ffd8da
commit 500bc5d042
26 changed files with 549 additions and 528 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

118
.eslintrc
View file

@ -1,118 +0,0 @@
env:
node: true
browser: false
plugins:
- nodeca
rules:
# block-scoped-var: 2
# brace-style: [ 2, '1tbs', { allowSingleLine: true } ]
# comma-spacing: 2
comma-style: 2
consistent-this: [ 2, self ]
consistent-return: 2
curly: 2
# default-case: 2
dot-notation: 2
eol-last: 2
eqeqeq: 2
# guard-for-in: 2
handle-callback-err: 2
# max-depth: [ 1, 6 ]
max-nested-callbacks: [ 1, 4 ]
# string can exceed 80 chars, but should not overflow github website :)
# max-len: [ 2, 120, 1000 ]
# new-cap: 2
new-parens: 2
no-alert: 2
no-array-constructor: 2
# no-bitwise: 2
no-caller: 2
no-catch-shadow: 2
no-comma-dangle: 2
no-cond-assign: 2
# no-console: 1
no-constant-condition: 2
no-control-regex: 2
no-debugger: 2
no-delete-var: 2
no-dupe-keys: 2
no-div-regex: 2
# no-empty: 2
no-empty-class: 2
no-empty-label: 2
no-else-return: 2
no-eq-null: 2
no-ex-assign: 2
no-extend-native: 2
no-extra-bind: 2
no-extra-boolean-cast: 2
no-extra-semi: 2
no-extra-strict: 2
no-eval: 2
no-floating-decimal: 2
no-func-assign: 2
no-implied-eval: 2
no-inner-declarations: 2
no-invalid-regexp: 2
no-irregular-whitespace: 2
no-label-var: 2
# no-labels: 2
no-lone-blocks: 2
no-lonely-if: 2
no-loop-func: 2
no-mixed-requires: 2
no-mixed-spaces-and-tabs: 2
no-multi-str: 2
no-native-reassign: 2
no-negated-in-lhs: 2
no-new: 2
no-new-func: 2
no-new-object: 2
no-new-require: 2
no-new-wrappers: 2
no-obj-calls: 2
no-octal: 2
no-octal-escape: 2
no-path-concat: 2
no-redeclare: 2
no-regex-spaces: 2
no-reserved-keys: 2
no-return-assign: 2
no-script-url: 2
no-sequences: 2
no-shadow: 2
no-shadow-restricted-names: 2
# no-space-before-semi: 2
no-sparse-arrays: 2
no-trailing-spaces: 2
no-undef: 2
no-undef-init: 2
no-undefined: 2
no-unreachable: 2
no-unused-expressions: 2
no-unused-vars: 2
no-use-before-define: 2
no-with: 2
no-wrap-func: 2
quotes: [ 2, single, avoid-escape ]
radix: 2
semi: 2
space-after-keywords: [ 2, always, , { "checkFunctionKeyword": true } ]
space-before-blocks: 2
# space-in-brackets: [ 2, always, { propertyName: false } ]
space-in-parens: [ 2, never ]
# space-infix-ops: 2
space-return-throw-case: 2
space-unary-ops: 2
# spaced-line-comment: [ 2, always, { exceptions: [ '/' ] } ]
strict: 2
use-isnan: 2
yoda: 2
valid-typeof: 2
#
# Our custom rules
#
nodeca/indent: [ 2, spaces, 2 ]

131
.eslintrc.yml Normal file
View file

@ -0,0 +1,131 @@
env:
node: true
es6: true
plugins:
- nodeca
rules:
accessor-pairs: 2
array-bracket-spacing: [ 2, "always", { "singleValue": true, "objectsInArrays": true, "arraysInArrays": true } ]
block-scoped-var: 2
block-spacing: 2
#brace-style: [ 2, '1tbs', { "allowSingleLine": true } ]
#callback-return: 2
comma-dangle: 2
comma-spacing: 2
comma-style: 2
computed-property-spacing: [ 2, never ]
#consistent-return: 2
consistent-this: [ 2, self ]
curly: [ 2, 'multi-line' ]
# dot-notation: [ 2, { allowKeywords: true } ]
dot-location: [ 2, 'property' ]
eol-last: 2
eqeqeq: 2
func-style: [ 2, declaration ]
guard-for-in: 2
handle-callback-err: 2
#indent: [ 2, 2, { VariableDeclarator: { var: 2, let: 2, const: 3 }, SwitchCase: 1 } ]
# key-spacing: [ 2, { "align": "value" } ]
keyword-spacing: 2
linebreak-style: 2
#max-depth: [ 1, 3 ]
max-nested-callbacks: [ 1, 7 ]
# string can exceed 80 chars, but should not overflow github website :)
#max-len: [ 2, 120, 1000 ]
new-cap: 2
new-parens: 2
no-alert: 2
no-array-constructor: 2
# no-bitwise: 2
no-caller: 2
no-case-declarations: 2
no-catch-shadow: 2
no-cond-assign: 2
no-console: 1
no-constant-condition: 2
no-control-regex: 2
no-debugger: 1
no-delete-var: 2
no-div-regex: 2
no-dupe-args: 2
no-dupe-keys: 2
no-duplicate-case: 2
no-else-return: 2
# no-empty: 1
no-empty-character-class: 2
no-empty-pattern: 2
no-eq-null: 2
no-eval: 2
no-ex-assign: 2
no-extend-native: 2
no-extra-bind: 2
no-extra-boolean-cast: 2
no-extra-semi: 2
no-fallthrough: 2
no-floating-decimal: 2
no-func-assign: 2
no-implied-eval: 2
no-inner-declarations: 2
no-invalid-regexp: 2
no-irregular-whitespace: 2
no-iterator: 2
#no-labels: 2
no-label-var: 2
no-lone-blocks: 1
no-lonely-if: 2
no-loop-func: 2
no-mixed-requires: [ 1, { "grouping": true } ]
no-mixed-spaces-and-tabs: 2
no-native-reassign: 2
no-negated-in-lhs: 2
no-new: 2
no-new-func: 2
no-new-object: 2
no-new-require: 2
no-new-wrappers: 2
no-obj-calls: 2
no-octal: 2
no-octal-escape: 2
no-path-concat: 2
no-proto: 2
no-redeclare: 2
# no-regex-spaces: 2
no-return-assign: 2
no-self-compare: 2
no-sequences: 2
# no-shadow: 2
no-shadow-restricted-names: 2
no-sparse-arrays: 2
no-throw-literal: 2
no-trailing-spaces: 2
no-undef: 2
no-undef-init: 2
no-undefined: 2
no-unexpected-multiline: 2
no-unreachable: 2
no-unused-expressions: 2
no-unused-vars: 2
no-use-before-define: 2
no-void: 2
no-with: 2
object-curly-spacing: [ 2, always, { "objectsInObjects": true, "arraysInObjects": true } ]
operator-assignment: 1
semi: 2
semi-spacing: 2
space-before-blocks: 2
space-before-function-paren: [ 2, { "anonymous": "always", "named": "never" } ]
space-in-parens: [ 2, never ]
space-infix-ops: [ 2, { int32Hint: true } ]
space-unary-ops: 2
#spaced-comment: [ 1, always, { exceptions: [ '/', '=' ] } ]
strict: [ 2, global ]
quotes: [ 2, single, avoid-escape ]
quote-props: [ 1, 'as-needed', { "keywords": true } ]
radix: 2
use-isnan: 2
valid-typeof: 2
yoda: [ 2, never, { "exceptRange": true } ]
nodeca/indent: [2, spaces, 2]

12
Gruntfile.js
View file

@ -1,8 +1,8 @@
'use strict';
module.exports = function(grunt) {
var browsers = [{
module.exports = function (grunt) {
var browsers = [ {
browserName: 'iphone',
platform: 'OS X 10.8',
version: '8.1'
@ -46,7 +46,7 @@ module.exports = function(grunt) {
browserName: 'safari',
platform: 'OS X 10.8',
version: '6'
}];
} ];
grunt.initConfig({
@ -61,8 +61,8 @@ module.exports = function(grunt) {
'saucelabs-mocha': {
all: {
options: {
urls: ['http://127.0.0.1:9999/test/browser/test.html'],
build: process.env.TRAVIS_JOB_NUMBER || ('local' + ~~(Math.random()*1000)),
urls: [ 'http://127.0.0.1:9999/test/browser/test.html' ],
build: process.env.TRAVIS_JOB_NUMBER || ('local' + ~~(Math.random() * 1000)),
browsers: browsers,
throttled: 3,
testname: process.env.SAUCE_PROJ || 'mocha tests'
@ -78,5 +78,5 @@ module.exports = function(grunt) {
}
//grunt.registerTask('dev', ['connect', 'watch']);
grunt.registerTask('test', ['connect', 'saucelabs-mocha']);
grunt.registerTask('test', [ 'connect', 'saucelabs-mocha' ]);
};

22
Makefile
View file

@ -23,24 +23,24 @@ help:
lint:
eslint --reset .
./node_modules/.bin/eslint .
test: lint
mocha
./node_modules/.bin/mocha
test-browser: lint
rm -f ./test/browser/pako.js
browserify -r ./ -s pako > test/browser/pako.js
./node_modules/.bin/browserify -r ./ -s pako > test/browser/pako.js
@SAUCE_PROJ=${GITHUB_PROJ} grunt test
cover:
rm -rf cover
istanbul cover node_modules/.bin/_mocha
./node_modules/.bin/istanbul cover node_modules/.bin/_mocha
doc:
rm -rf ./doc
ndoc --link-format "{package.homepage}/blob/${CURR_HEAD}/{file}#L{line}"
./node_modules/.bin/ndoc --link-format "{package.homepage}/blob/${CURR_HEAD}/{file}#L{line}"
browserify:
@ -48,22 +48,22 @@ browserify:
mkdir dist
# Browserify
( echo -n "/* ${NPM_PACKAGE} ${NPM_VERSION} ${GITHUB_PROJ} */" ; \
browserify -r ./ -s pako \
./node_modules/.bin/browserify -r ./ -s pako \
) > dist/pako.js
( echo -n "/* ${NPM_PACKAGE} ${NPM_VERSION} ${GITHUB_PROJ} */" ; \
browserify -r ./lib/deflate.js -s pako \
./node_modules/.bin/browserify -r ./lib/deflate.js -s pako \
) > dist/pako_deflate.js
( echo -n "/* ${NPM_PACKAGE} ${NPM_VERSION} ${GITHUB_PROJ} */" ; \
browserify -r ./lib/inflate.js -s pako \
./node_modules/.bin/browserify -r ./lib/inflate.js -s pako \
) > dist/pako_inflate.js
# Minify
uglifyjs dist/pako.js -c -m \
./node_modules/.bin/uglifyjs dist/pako.js -c -m \
--preamble "/* ${NPM_PACKAGE} ${NPM_VERSION} ${GITHUB_PROJ} */" \
> dist/pako.min.js
uglifyjs dist/pako_deflate.js -c -m \
./node_modules/.bin/uglifyjs dist/pako_deflate.js -c -m \
--preamble "/* ${NPM_PACKAGE} ${NPM_VERSION} ${GITHUB_PROJ} */" \
> dist/pako_deflate.min.js
uglifyjs dist/pako_inflate.js -c -m \
./node_modules/.bin/uglifyjs dist/pako_inflate.js -c -m \
--preamble "/* ${NPM_PACKAGE} ${NPM_VERSION} ${GITHUB_PROJ} */" \
> dist/pako_inflate.min.js
# Update bower package

3
benchmark/benchmark.js
View file

@ -30,6 +30,7 @@ fs.readdirSync(IMPLS_DIRECTORY).sort().forEach(function (name) {
});
});
/* eslint-disable no-console */
var SAMPLES_DIRECTORY = path.join(__dirname, 'samples');
var SAMPLES = [];
@ -86,7 +87,7 @@ fs.readdirSync(SAMPLES_DIRECTORY).sort().forEach(function (sample) {
fn: function (deferred) {
if (impl.code.async) {
impl.code.run(content, LEVEL, function() {
impl.code.run(content, LEVEL, function () {
deferred.resolve();
return;
});

2
benchmark/profile.js
View file

@ -8,6 +8,6 @@ var data = new Uint8Array(fs.readFileSync(path.join(__dirname, '/samples/lorem_1
var deflated = pako.deflate(data, { level: 6/*, to: 'string'*/ });
for (var i=0; i<200; i++) {
for (var i = 0; i < 200; i++) {
pako.inflate(deflated, { to: 'string' });
}

20
lib/deflate.js
View file

@ -2,10 +2,10 @@
var zlib_deflate = require('./zlib/deflate.js');
var utils = require('./utils/common');
var strings = require('./utils/strings');
var msg = require('./zlib/messages');
var zstream = require('./zlib/zstream');
var utils = require('./utils/common');
var strings = require('./utils/strings');
var msg = require('./zlib/messages');
var ZStream = require('./zlib/zstream');
var toString = Object.prototype.toString;
@ -116,7 +116,7 @@ var Z_DEFLATED = 8;
* console.log(deflate.result);
* ```
**/
var Deflate = function(options) {
function Deflate(options) {
this.options = utils.assign({
level: Z_DEFAULT_COMPRESSION,
@ -143,7 +143,7 @@ var Deflate = function(options) {
this.ended = false; // used to avoid multiple onEnd() calls
this.chunks = []; // chunks of compressed data
this.strm = new zstream();
this.strm = new ZStream();
this.strm.avail_out = 0;
var status = zlib_deflate.deflateInit2(
@ -162,7 +162,7 @@ var Deflate = function(options) {
if (opt.header) {
zlib_deflate.deflateSetHeader(this.strm, opt.header);
}
};
}
/**
* Deflate#push(data[, mode]) -> Boolean
@ -193,7 +193,7 @@ var Deflate = function(options) {
* push(chunk, true); // push last chunk
* ```
**/
Deflate.prototype.push = function(data, mode) {
Deflate.prototype.push = function (data, mode) {
var strm = this.strm;
var chunkSize = this.options.chunkSize;
var status, _mode;
@ -265,7 +265,7 @@ Deflate.prototype.push = function(data, mode) {
* By default, stores data blocks in `chunks[]` property and glue
* those in `onEnd`. Override this handler, if you need another behaviour.
**/
Deflate.prototype.onData = function(chunk) {
Deflate.prototype.onData = function (chunk) {
this.chunks.push(chunk);
};
@ -280,7 +280,7 @@ Deflate.prototype.onData = function(chunk) {
* or if an error happened. By default - join collected chunks,
* free memory and fill `results` / `err` properties.
**/
Deflate.prototype.onEnd = function(status) {
Deflate.prototype.onEnd = function (status) {
// On success - join
if (status === Z_OK) {
if (this.options.to === 'string') {

26
lib/inflate.js
View file

@ -2,12 +2,12 @@
var zlib_inflate = require('./zlib/inflate.js');
var utils = require('./utils/common');
var strings = require('./utils/strings');
var c = require('./zlib/constants');
var msg = require('./zlib/messages');
var zstream = require('./zlib/zstream');
var gzheader = require('./zlib/gzheader');
var utils = require('./utils/common');
var strings = require('./utils/strings');
var c = require('./zlib/constants');
var msg = require('./zlib/messages');
var ZStream = require('./zlib/zstream');
var GZheader = require('./zlib/gzheader');
var toString = Object.prototype.toString;
@ -89,7 +89,7 @@ var toString = Object.prototype.toString;
* console.log(inflate.result);
* ```
**/
var Inflate = function(options) {
function Inflate(options) {
this.options = utils.assign({
chunkSize: 16384,
@ -127,7 +127,7 @@ var Inflate = function(options) {
this.ended = false; // used to avoid multiple onEnd() calls
this.chunks = []; // chunks of compressed data
this.strm = new zstream();
this.strm = new ZStream();
this.strm.avail_out = 0;
var status = zlib_inflate.inflateInit2(
@ -139,10 +139,10 @@ var Inflate = function(options) {
throw new Error(msg[status]);
}
this.header = new gzheader();
this.header = new GZheader();
zlib_inflate.inflateGetHeader(this.strm, this.header);
};
}
/**
* Inflate#push(data[, mode]) -> Boolean
@ -172,7 +172,7 @@ var Inflate = function(options) {
* push(chunk, true); // push last chunk
* ```
**/
Inflate.prototype.push = function(data, mode) {
Inflate.prototype.push = function (data, mode) {
var strm = this.strm;
var chunkSize = this.options.chunkSize;
var status, _mode;
@ -286,7 +286,7 @@ Inflate.prototype.push = function(data, mode) {
* 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) {
Inflate.prototype.onData = function (chunk) {
this.chunks.push(chunk);
};
@ -301,7 +301,7 @@ Inflate.prototype.onData = function(chunk) {
* or if an error happened. By default - join collected chunks,
* free memory and fill `results` / `err` properties.
**/
Inflate.prototype.onEnd = function(status) {
Inflate.prototype.onEnd = function (status) {
// On success - join
if (status === c.Z_OK) {
if (this.options.to === 'string') {

14
lib/utils/common.js
View file

@ -39,28 +39,28 @@ exports.shrinkBuf = function (buf, size) {
var fnTyped = {
arraySet: function (dest, src, src_offs, len, dest_offs) {
if (src.subarray && dest.subarray) {
dest.set(src.subarray(src_offs, src_offs+len), dest_offs);
dest.set(src.subarray(src_offs, src_offs + len), dest_offs);
return;
}
// Fallback to ordinary array
for (var i=0; i<len; i++) {
for (var i = 0; i < len; i++) {
dest[dest_offs + i] = src[src_offs + i];
}
},
// Join array of chunks to single array.
flattenChunks: function(chunks) {
flattenChunks: function (chunks) {
var i, l, len, pos, chunk, result;
// calculate data length
len = 0;
for (i=0, l=chunks.length; i<l; i++) {
for (i = 0, l = chunks.length; i < l; i++) {
len += chunks[i].length;
}
// join chunks
result = new Uint8Array(len);
pos = 0;
for (i=0, l=chunks.length; i<l; i++) {
for (i = 0, l = chunks.length; i < l; i++) {
chunk = chunks[i];
result.set(chunk, pos);
pos += chunk.length;
@ -72,12 +72,12 @@ var fnTyped = {
var fnUntyped = {
arraySet: function (dest, src, src_offs, len, dest_offs) {
for (var i=0; i<len; i++) {
for (var i = 0; i < len; i++) {
dest[dest_offs + i] = src[src_offs + i];
}
},
// Join array of chunks to single array.
flattenChunks: function(chunks) {
flattenChunks: function (chunks) {
return [].concat.apply([], chunks);
}
};

36
lib/utils/strings.js
View file

@ -13,18 +13,18 @@ var utils = require('./common');
var STR_APPLY_OK = true;
var STR_APPLY_UIA_OK = true;
try { String.fromCharCode.apply(null, [0]); } catch(__) { STR_APPLY_OK = false; }
try { String.fromCharCode.apply(null, new Uint8Array(1)); } catch(__) { STR_APPLY_UIA_OK = false; }
try { String.fromCharCode.apply(null, [ 0 ]); } catch (__) { STR_APPLY_OK = false; }
try { String.fromCharCode.apply(null, new Uint8Array(1)); } catch (__) { STR_APPLY_UIA_OK = false; }
// Table with utf8 lengths (calculated by first byte of sequence)
// Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,
// because max possible codepoint is 0x10ffff
var _utf8len = new utils.Buf8(256);
for (var q=0; q<256; q++) {
for (var q = 0; q < 256; q++) {
_utf8len[q] = (q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1);
}
_utf8len[254]=_utf8len[254]=1; // Invalid sequence start
_utf8len[254] = _utf8len[254] = 1; // Invalid sequence start
// convert string to array (typed, when possible)
@ -34,8 +34,8 @@ exports.string2buf = function (str) {
// count binary size
for (m_pos = 0; m_pos < str_len; m_pos++) {
c = str.charCodeAt(m_pos);
if ((c & 0xfc00) === 0xd800 && (m_pos+1 < str_len)) {
c2 = str.charCodeAt(m_pos+1);
if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
c2 = str.charCodeAt(m_pos + 1);
if ((c2 & 0xfc00) === 0xdc00) {
c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
m_pos++;
@ -48,10 +48,10 @@ exports.string2buf = function (str) {
buf = new utils.Buf8(buf_len);
// convert
for (i=0, m_pos = 0; i < buf_len; m_pos++) {
for (i = 0, m_pos = 0; i < buf_len; m_pos++) {
c = str.charCodeAt(m_pos);
if ((c & 0xfc00) === 0xd800 && (m_pos+1 < str_len)) {
c2 = str.charCodeAt(m_pos+1);
if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
c2 = str.charCodeAt(m_pos + 1);
if ((c2 & 0xfc00) === 0xdc00) {
c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
m_pos++;
@ -91,7 +91,7 @@ function buf2binstring(buf, len) {
}
var result = '';
for (var i=0; i < len; i++) {
for (var i = 0; i < len; i++) {
result += String.fromCharCode(buf[i]);
}
return result;
@ -99,15 +99,15 @@ function buf2binstring(buf, len) {
// Convert byte array to binary string
exports.buf2binstring = function(buf) {
exports.buf2binstring = function (buf) {
return buf2binstring(buf, buf.length);
};
// Convert binary string (typed, when possible)
exports.binstring2buf = function(str) {
exports.binstring2buf = function (str) {
var buf = new utils.Buf8(str.length);
for (var i=0, len=buf.length; i < len; i++) {
for (var i = 0, len = buf.length; i < len; i++) {
buf[i] = str.charCodeAt(i);
}
return buf;
@ -122,16 +122,16 @@ exports.buf2string = function (buf, max) {
// Reserve max possible length (2 words per char)
// NB: by unknown reasons, Array is significantly faster for
// String.fromCharCode.apply than Uint16Array.
var utf16buf = new Array(len*2);
var utf16buf = new Array(len * 2);
for (out=0, i=0; i<len;) {
for (out = 0, i = 0; i < len;) {
c = buf[i++];
// quick process ascii
if (c < 0x80) { utf16buf[out++] = c; continue; }
c_len = _utf8len[c];
// skip 5 & 6 byte codes
if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len-1; continue; }
if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len - 1; continue; }
// apply mask on first byte
c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;
@ -163,14 +163,14 @@ exports.buf2string = function (buf, max) {
//
// buf[] - utf8 bytes array
// max - length limit (mandatory);
exports.utf8border = function(buf, max) {
exports.utf8border = function (buf, max) {
var pos;
max = max || buf.length;
if (max > buf.length) { max = buf.length; }
// go back from last position, until start of sequence found
pos = max-1;
pos = max - 1;
while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; }
// Fuckup - very small and broken sequence,

3
lib/zlib/constants.js
View file

@ -1,3 +1,6 @@
'use strict';
module.exports = {
/* Allowed flush values; see deflate() and inflate() below for details */

8
lib/zlib/crc32.js
View file

@ -9,10 +9,10 @@
function makeTable() {
var c, table = [];
for (var n =0; n < 256; n++) {
for (var n = 0; n < 256; n++) {
c = n;
for (var k =0; k < 8; k++) {
c = ((c&1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
for (var k = 0; k < 8; k++) {
c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
}
table[n] = c;
}
@ -28,7 +28,7 @@ function crc32(crc, buf, len, pos) {
var t = crcTable,
end = pos + len;
crc = crc ^ (-1);
crc ^= -1;
for (var i = pos; i < end; i++) {
crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];

42
lib/zlib/deflate.js
View file

@ -4,7 +4,7 @@ var utils = require('../utils/common');
var trees = require('./trees');
var adler32 = require('./adler32');
var crc32 = require('./crc32');
var msg = require('./messages');
var msg = require('./messages');
/* Public constants ==========================================================*/
/* ===========================================================================*/
@ -77,7 +77,7 @@ var D_CODES = 30;
/* number of distance codes */
var BL_CODES = 19;
/* number of codes used to transfer the bit lengths */
var HEAP_SIZE = 2*L_CODES + 1;
var HEAP_SIZE = 2 * L_CODES + 1;
/* maximum heap size */
var MAX_BITS = 15;
/* All codes must not exceed MAX_BITS bits */
@ -143,7 +143,7 @@ function flush_pending(strm) {
}
function flush_block_only (s, last) {
function flush_block_only(s, last) {
trees._tr_flush_block(s, (s.block_start >= 0 ? s.block_start : -1), s.strstart - s.block_start, last);
s.block_start = s.strstart;
flush_pending(s.strm);
@ -413,7 +413,7 @@ function fill_window(s) {
//#endif
while (s.insert) {
/* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */
s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH-1]) & s.hash_mask;
s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;
s.prev[str & s.w_mask] = s.head[s.ins_h];
s.head[s.ins_h] = str;
@ -677,7 +677,7 @@ function deflate_fast(s, flush) {
/***/
}
}
s.insert = ((s.strstart < (MIN_MATCH-1)) ? s.strstart : MIN_MATCH-1);
s.insert = ((s.strstart < (MIN_MATCH - 1)) ? s.strstart : MIN_MATCH - 1);
if (flush === Z_FINISH) {
/*** FLUSH_BLOCK(s, 1); ***/
flush_block_only(s, true);
@ -740,10 +740,10 @@ function deflate_slow(s, flush) {
*/
s.prev_length = s.match_length;
s.prev_match = s.match_start;
s.match_length = MIN_MATCH-1;
s.match_length = MIN_MATCH - 1;
if (hash_head !== 0/*NIL*/ && s.prev_length < s.max_lazy_match &&
s.strstart - hash_head <= (s.w_size-MIN_LOOKAHEAD)/*MAX_DIST(s)*/) {
s.strstart - hash_head <= (s.w_size - MIN_LOOKAHEAD)/*MAX_DIST(s)*/) {
/* To simplify the code, we prevent matches with the string
* of window index 0 (in particular we have to avoid a match
* of the string with itself at the start of the input file).
@ -757,7 +757,7 @@ function deflate_slow(s, flush) {
/* If prev_match is also MIN_MATCH, match_start is garbage
* but we will ignore the current match anyway.
*/
s.match_length = MIN_MATCH-1;
s.match_length = MIN_MATCH - 1;
}
}
/* If there was a match at the previous step and the current
@ -771,13 +771,13 @@ function deflate_slow(s, flush) {
/***_tr_tally_dist(s, s.strstart - 1 - s.prev_match,
s.prev_length - MIN_MATCH, bflush);***/
bflush = trees._tr_tally(s, s.strstart - 1- s.prev_match, s.prev_length - MIN_MATCH);
bflush = trees._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH);
/* Insert in hash table all strings up to the end of the match.
* strstart-1 and strstart are already inserted. If there is not
* enough lookahead, the last two strings are not inserted in
* the hash table.
*/
s.lookahead -= s.prev_length-1;
s.lookahead -= s.prev_length - 1;
s.prev_length -= 2;
do {
if (++s.strstart <= max_insert) {
@ -789,7 +789,7 @@ function deflate_slow(s, flush) {
}
} while (--s.prev_length !== 0);
s.match_available = 0;
s.match_length = MIN_MATCH-1;
s.match_length = MIN_MATCH - 1;
s.strstart++;
if (bflush) {
@ -808,7 +808,7 @@ function deflate_slow(s, flush) {
*/
//Tracevv((stderr,"%c", s->window[s->strstart-1]));
/*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
bflush = trees._tr_tally(s, 0, s.window[s.strstart-1]);
bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);
if (bflush) {
/*** FLUSH_BLOCK_ONLY(s, 0) ***/
@ -833,11 +833,11 @@ function deflate_slow(s, flush) {
if (s.match_available) {
//Tracevv((stderr,"%c", s->window[s->strstart-1]));
/*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
bflush = trees._tr_tally(s, 0, s.window[s.strstart-1]);
bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);
s.match_available = 0;
}
s.insert = s.strstart < MIN_MATCH-1 ? s.strstart : MIN_MATCH-1;
s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;
if (flush === Z_FINISH) {
/*** FLUSH_BLOCK(s, 1); ***/
flush_block_only(s, true);
@ -1017,13 +1017,13 @@ function deflate_huff(s, flush) {
* exclude worst case performance for pathological files. Better values may be
* found for specific files.
*/
var Config = function (good_length, max_lazy, nice_length, max_chain, func) {
function Config(good_length, max_lazy, nice_length, max_chain, func) {
this.good_length = good_length;
this.max_lazy = max_lazy;
this.nice_length = nice_length;
this.max_chain = max_chain;
this.func = func;
};
}
var configuration_table;
@ -1173,8 +1173,8 @@ function DeflateState() {
// Use flat array of DOUBLE size, with interleaved fata,
// because JS does not support effective
this.dyn_ltree = new utils.Buf16(HEAP_SIZE * 2);
this.dyn_dtree = new utils.Buf16((2*D_CODES+1) * 2);
this.bl_tree = new utils.Buf16((2*BL_CODES+1) * 2);
this.dyn_dtree = new utils.Buf16((2 * D_CODES + 1) * 2);
this.bl_tree = new utils.Buf16((2 * BL_CODES + 1) * 2);
zero(this.dyn_ltree);
zero(this.dyn_dtree);
zero(this.bl_tree);
@ -1184,11 +1184,11 @@ function DeflateState() {
this.bl_desc = null; /* desc. for bit length tree */
//ush bl_count[MAX_BITS+1];
this.bl_count = new utils.Buf16(MAX_BITS+1);
this.bl_count = new utils.Buf16(MAX_BITS + 1);
/* number of codes at each bit length for an optimal tree */
//int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */
this.heap = new utils.Buf16(2*L_CODES+1); /* heap used to build the Huffman trees */
this.heap = new utils.Buf16(2 * L_CODES + 1); /* heap used to build the Huffman trees */
zero(this.heap);
this.heap_len = 0; /* number of elements in the heap */
@ -1197,7 +1197,7 @@ function DeflateState() {
* The same heap array is used to build all trees.
*/
this.depth = new utils.Buf16(2*L_CODES+1); //uch depth[2*L_CODES+1];
this.depth = new utils.Buf16(2 * L_CODES + 1); //uch depth[2*L_CODES+1];
zero(this.depth);
/* Depth of each subtree used as tie breaker for trees of equal frequency
*/

48
lib/zlib/inflate.js
View file

@ -1,10 +1,10 @@
'use strict';
var utils = require('../utils/common');
var adler32 = require('./adler32');
var crc32 = require('./crc32');
var inflate_fast = require('./inffast');
var utils = require('../utils/common');
var adler32 = require('./adler32');
var crc32 = require('./crc32');
var inflate_fast = require('./inffast');
var inflate_table = require('./inftrees');
var CODES = 0;
@ -92,7 +92,7 @@ var MAX_WBITS = 15;
var DEF_WBITS = MAX_WBITS;
function ZSWAP32(q) {
function zswap32(q) {
return (((q >>> 24) & 0xff) +
((q >>> 8) & 0xff00) +
((q & 0xff00) << 8) +
@ -285,13 +285,13 @@ function fixedtables(state) {
while (sym < 280) { state.lens[sym++] = 7; }
while (sym < 288) { state.lens[sym++] = 8; }
inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, {bits: 9});
inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 });
/* distance table */
sym = 0;
while (sym < 32) { state.lens[sym++] = 5; }
inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, {bits: 5});
inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 });
/* do this just once */
virgin = false;
@ -333,7 +333,7 @@ function updatewindow(strm, src, end, copy) {
/* copy state->wsize or less output bytes into the circular window */
if (copy >= state.wsize) {
utils.arraySet(state.window,src, end - state.wsize, state.wsize, 0);
utils.arraySet(state.window, src, end - state.wsize, state.wsize, 0);
state.wnext = 0;
state.whave = state.wsize;
}
@ -343,11 +343,11 @@ function updatewindow(strm, src, end, copy) {
dist = copy;
}
//zmemcpy(state->window + state->wnext, end - copy, dist);
utils.arraySet(state.window,src, end - copy, dist, state.wnext);
utils.arraySet(state.window, src, end - copy, dist, state.wnext);
copy -= dist;
if (copy) {
//zmemcpy(state->window, end - copy, copy);
utils.arraySet(state.window,src, end - copy, copy, 0);
utils.arraySet(state.window, src, end - copy, copy, 0);
state.wnext = copy;
state.whave = state.wsize;
}
@ -384,7 +384,7 @@ function inflate(strm, flush) {
var n; // temporary var for NEED_BITS
var order = /* permutation of code lengths */
[16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
[ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ];
if (!strm || !strm.state || !strm.output ||
@ -711,7 +711,7 @@ function inflate(strm, flush) {
state.head.hcrc = ((state.flags >> 9) & 1);
state.head.done = true;
}
strm.adler = state.check = 0 /*crc32(0L, Z_NULL, 0)*/;
strm.adler = state.check = 0;
state.mode = TYPE;
break;
case DICTID:
@ -723,7 +723,7 @@ function inflate(strm, flush) {
bits += 8;
}
//===//
strm.adler = state.check = ZSWAP32(hold);
strm.adler = state.check = zswap32(hold);
//=== INITBITS();
hold = 0;
bits = 0;
@ -915,7 +915,7 @@ function inflate(strm, flush) {
state.lencode = state.lendyn;
state.lenbits = 7;
opts = {bits: state.lenbits};
opts = { bits: state.lenbits };
ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);
state.lenbits = opts.bits;
@ -1046,7 +1046,7 @@ function inflate(strm, flush) {
concerning the ENOUGH constants, which depend on those values */
state.lenbits = 9;
opts = {bits: state.lenbits};
opts = { bits: state.lenbits };
ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);
// We have separate tables & no pointers. 2 commented lines below not needed.
// state.next_index = opts.table_index;
@ -1063,7 +1063,7 @@ function inflate(strm, flush) {
//state.distcode.copy(state.codes);
// Switch to use dynamic table
state.distcode = state.distdyn;
opts = {bits: state.distbits};
opts = { bits: state.distbits };
ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);
// We have separate tables & no pointers. 2 commented lines below not needed.
// state.next_index = opts.table_index;
@ -1111,7 +1111,7 @@ function inflate(strm, flush) {
}
state.back = 0;
for (;;) {
here = state.lencode[hold & ((1 << state.lenbits) -1)]; /*BITS(state.lenbits)*/
here = state.lencode[hold & ((1 << state.lenbits) - 1)]; /*BITS(state.lenbits)*/
here_bits = here >>> 24;
here_op = (here >>> 16) & 0xff;
here_val = here & 0xffff;
@ -1130,7 +1130,7 @@ function inflate(strm, flush) {
last_val = here_val;
for (;;) {
here = state.lencode[last_val +
((hold & ((1 << (last_bits + last_op)) -1))/*BITS(last.bits + last.op)*/ >> last_bits)];
((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];
here_bits = here >>> 24;
here_op = (here >>> 16) & 0xff;
here_val = here & 0xffff;
@ -1187,7 +1187,7 @@ function inflate(strm, flush) {
bits += 8;
}
//===//
state.length += hold & ((1 << state.extra) -1)/*BITS(state.extra)*/;
state.length += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;
//--- DROPBITS(state.extra) ---//
hold >>>= state.extra;
bits -= state.extra;
@ -1200,7 +1200,7 @@ function inflate(strm, flush) {
/* falls through */
case DIST:
for (;;) {
here = state.distcode[hold & ((1 << state.distbits) -1)];/*BITS(state.distbits)*/
here = state.distcode[hold & ((1 << state.distbits) - 1)];/*BITS(state.distbits)*/
here_bits = here >>> 24;
here_op = (here >>> 16) & 0xff;
here_val = here & 0xffff;
@ -1219,7 +1219,7 @@ function inflate(strm, flush) {
last_val = here_val;
for (;;) {
here = state.distcode[last_val +
((hold & ((1 << (last_bits + last_op)) -1))/*BITS(last.bits + last.op)*/ >> last_bits)];
((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];
here_bits = here >>> 24;
here_op = (here >>> 16) & 0xff;
here_val = here & 0xffff;
@ -1263,7 +1263,7 @@ function inflate(strm, flush) {
bits += 8;
}
//===//
state.offset += hold & ((1 << state.extra) -1)/*BITS(state.extra)*/;
state.offset += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;
//--- DROPBITS(state.extra) ---//
hold >>>= state.extra;
bits -= state.extra;
@ -1357,8 +1357,8 @@ function inflate(strm, flush) {
}
_out = left;
// NB: crc32 stored as signed 32-bit int, ZSWAP32 returns signed too
if ((state.flags ? hold : ZSWAP32(hold)) !== state.check) {
// NB: crc32 stored as signed 32-bit int, zswap32 returns signed too
if ((state.flags ? hold : zswap32(hold)) !== state.check) {
strm.msg = 'incorrect data check';
state.mode = BAD;
break;

6
lib/zlib/inftrees.js
View file

@ -57,8 +57,8 @@ module.exports = function inflate_table(type, lens, lens_index, codes, table, ta
var base_index = 0;
// var shoextra; /* extra bits table to use */
var end; /* use base and extra for symbol > end */
var count = new utils.Buf16(MAXBITS+1); //[MAXBITS+1]; /* number of codes of each length */
var offs = new utils.Buf16(MAXBITS+1); //[MAXBITS+1]; /* offsets in table for each length */
var count = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* number of codes of each length */
var offs = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* offsets in table for each length */
var extra = null;
var extra_index = 0;
@ -227,7 +227,7 @@ module.exports = function inflate_table(type, lens, lens_index, codes, table, ta
return 1;
}
var i=0;
var i = 0;
/* process all codes and make table entries */
for (;;) {
i++;

6
lib/zlib/messages.js
View file

@ -1,9 +1,9 @@
'use strict';
module.exports = {
'2': 'need dictionary', /* Z_NEED_DICT 2 */
'1': 'stream end', /* Z_STREAM_END 1 */
'0': '', /* Z_OK 0 */
2: 'need dictionary', /* Z_NEED_DICT 2 */
1: 'stream end', /* Z_STREAM_END 1 */
0: '', /* Z_OK 0 */
'-1': 'file error', /* Z_ERRNO (-1) */
'-2': 'stream error', /* Z_STREAM_ERROR (-2) */
'-3': 'data error', /* Z_DATA_ERROR (-3) */

171
lib/zlib/trees.js
View file

@ -55,7 +55,7 @@ var D_CODES = 30;
var BL_CODES = 19;
/* number of codes used to transfer the bit lengths */
var HEAP_SIZE = 2*L_CODES + 1;
var HEAP_SIZE = 2 * L_CODES + 1;
/* maximum heap size */
var MAX_BITS = 15;
@ -84,6 +84,7 @@ var REPZ_3_10 = 17;
var REPZ_11_138 = 18;
/* repeat a zero length 11-138 times (7 bits of repeat count) */
/* eslint-disable comma-spacing,array-bracket-spacing */
var extra_lbits = /* extra bits for each length code */
[0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0];
@ -95,6 +96,8 @@ var extra_blbits = /* extra bits for each bit length code */
var bl_order =
[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15];
/* eslint-enable comma-spacing,array-bracket-spacing */
/* The lengths of the bit length codes are sent in order of decreasing
* probability, to avoid transmitting the lengths for unused bit length codes.
*/
@ -108,7 +111,7 @@ var bl_order =
var DIST_CODE_LEN = 512; /* see definition of array dist_code below */
// !!!! Use flat array insdead of structure, Freq = i*2, Len = i*2+1
var static_ltree = new Array((L_CODES+2) * 2);
var static_ltree = new Array((L_CODES + 2) * 2);
zero(static_ltree);
/* The static literal tree. Since the bit lengths are imposed, there is no
* need for the L_CODES extra codes used during heap construction. However
@ -129,7 +132,7 @@ zero(_dist_code);
* the 15 bit distances.
*/
var _length_code = new Array(MAX_MATCH-MIN_MATCH+1);
var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1);
zero(_length_code);
/* length code for each normalized match length (0 == MIN_MATCH) */
@ -142,7 +145,7 @@ zero(base_dist);
/* First normalized distance for each code (0 = distance of 1) */
var StaticTreeDesc = function (static_tree, extra_bits, extra_base, elems, max_length) {
function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {
this.static_tree = static_tree; /* static tree or NULL */
this.extra_bits = extra_bits; /* extra bits for each code or NULL */
@ -152,7 +155,7 @@ var StaticTreeDesc = function (static_tree, extra_bits, extra_base, elems, max_l
// show if `static_tree` has data or dummy - needed for monomorphic objects
this.has_stree = static_tree && static_tree.length;
};
}
var static_l_desc;
@ -160,11 +163,11 @@ var static_d_desc;
var static_bl_desc;
var TreeDesc = function(dyn_tree, stat_desc) {
function TreeDesc(dyn_tree, stat_desc) {
this.dyn_tree = dyn_tree; /* the dynamic tree */
this.max_code = 0; /* largest code with non zero frequency */
this.stat_desc = stat_desc; /* the corresponding static tree */
};
}
@ -177,7 +180,7 @@ function d_code(dist) {
* Output a short LSB first on the stream.
* IN assertion: there is enough room in pendingBuf.
*/
function put_short (s, w) {
function put_short(s, w) {
// put_byte(s, (uch)((w) & 0xff));
// put_byte(s, (uch)((ush)(w) >> 8));
s.pending_buf[s.pending++] = (w) & 0xff;
@ -203,7 +206,7 @@ function send_bits(s, value, length) {
function send_code(s, c, tree) {
send_bits(s, tree[c*2]/*.Code*/, tree[c*2 + 1]/*.Len*/);
send_bits(s, tree[c * 2]/*.Code*/, tree[c * 2 + 1]/*.Len*/);
}
@ -275,16 +278,16 @@ function gen_bitlen(s, desc)
/* In a first pass, compute the optimal bit lengths (which may
* overflow in the case of the bit length tree).
*/
tree[s.heap[s.heap_max]*2 + 1]/*.Len*/ = 0; /* root of the heap */
tree[s.heap[s.heap_max] * 2 + 1]/*.Len*/ = 0; /* root of the heap */
for (h = s.heap_max+1; h < HEAP_SIZE; h++) {
for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {
n = s.heap[h];
bits = tree[tree[n*2 +1]/*.Dad*/ * 2 + 1]/*.Len*/ + 1;
bits = tree[tree[n * 2 + 1]/*.Dad*/ * 2 + 1]/*.Len*/ + 1;
if (bits > max_length) {
bits = max_length;
overflow++;
}
tree[n*2 + 1]/*.Len*/ = bits;
tree[n * 2 + 1]/*.Len*/ = bits;
/* We overwrite tree[n].Dad which is no longer needed */
if (n > max_code) { continue; } /* not a leaf node */
@ -292,12 +295,12 @@ function gen_bitlen(s, desc)
s.bl_count[bits]++;
xbits = 0;
if (n >= base) {
xbits = extra[n-base];
xbits = extra[n - base];
}
f = tree[n * 2]/*.Freq*/;
s.opt_len += f * (bits + xbits);
if (has_stree) {
s.static_len += f * (stree[n*2 + 1]/*.Len*/ + xbits);
s.static_len += f * (stree[n * 2 + 1]/*.Len*/ + xbits);
}
}
if (overflow === 0) { return; }
@ -307,10 +310,10 @@ function gen_bitlen(s, desc)
/* Find the first bit length which could increase: */
do {
bits = max_length-1;
bits = max_length - 1;
while (s.bl_count[bits] === 0) { bits--; }
s.bl_count[bits]--; /* move one leaf down the tree */
s.bl_count[bits+1] += 2; /* move one overflow item as its brother */
s.bl_count[bits + 1] += 2; /* move one overflow item as its brother */
s.bl_count[max_length]--;
/* The brother of the overflow item also moves one step up,
* but this does not affect bl_count[max_length]
@ -328,10 +331,10 @@ function gen_bitlen(s, desc)
while (n !== 0) {
m = s.heap[--h];
if (m > max_code) { continue; }
if (tree[m*2 + 1]/*.Len*/ !== bits) {
if (tree[m * 2 + 1]/*.Len*/ !== bits) {
// Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
s.opt_len += (bits - tree[m*2 + 1]/*.Len*/)*tree[m*2]/*.Freq*/;
tree[m*2 + 1]/*.Len*/ = bits;
s.opt_len += (bits - tree[m * 2 + 1]/*.Len*/) * tree[m * 2]/*.Freq*/;
tree[m * 2 + 1]/*.Len*/ = bits;
}
n--;
}
@ -352,7 +355,7 @@ function gen_codes(tree, max_code, bl_count)
// int max_code; /* largest code with non zero frequency */
// ushf *bl_count; /* number of codes at each bit length */
{
var next_code = new Array(MAX_BITS+1); /* next code value for each bit length */
var next_code = new Array(MAX_BITS + 1); /* next code value for each bit length */
var code = 0; /* running code value */
var bits; /* bit index */
var n; /* code index */
@ -361,7 +364,7 @@ function gen_codes(tree, max_code, bl_count)
* without bit reversal.
*/
for (bits = 1; bits <= MAX_BITS; bits++) {
next_code[bits] = code = (code + bl_count[bits-1]) << 1;
next_code[bits] = code = (code + bl_count[bits - 1]) << 1;
}
/* Check that the bit counts in bl_count are consistent. The last code
* must be all ones.
@ -371,10 +374,10 @@ function gen_codes(tree, max_code, bl_count)
//Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
for (n = 0; n <= max_code; n++) {
var len = tree[n*2 + 1]/*.Len*/;
var len = tree[n * 2 + 1]/*.Len*/;
if (len === 0) { continue; }
/* Now reverse the bits */
tree[n*2]/*.Code*/ = bi_reverse(next_code[len]++, len);
tree[n * 2]/*.Code*/ = bi_reverse(next_code[len]++, len);
//Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
// n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
@ -391,7 +394,7 @@ function tr_static_init() {
var length; /* length value */
var code; /* code value */
var dist; /* distance index */
var bl_count = new Array(MAX_BITS+1);
var bl_count = new Array(MAX_BITS + 1);
/* number of codes at each bit length for an optimal tree */
// do check in _tr_init()
@ -408,9 +411,9 @@ function tr_static_init() {
/* Initialize the mapping length (0..255) -> length code (0..28) */
length = 0;
for (code = 0; code < LENGTH_CODES-1; code++) {
for (code = 0; code < LENGTH_CODES - 1; code++) {
base_length[code] = length;
for (n = 0; n < (1<<extra_lbits[code]); n++) {
for (n = 0; n < (1 << extra_lbits[code]); n++) {
_length_code[length++] = code;
}
}
@ -419,13 +422,13 @@ function tr_static_init() {
* in two different ways: code 284 + 5 bits or code 285, so we
* overwrite length_code[255] to use the best encoding:
*/
_length_code[length-1] = code;
_length_code[length - 1] = code;
/* Initialize the mapping dist (0..32K) -> dist code (0..29) */
dist = 0;
for (code = 0 ; code < 16; code++) {
for (code = 0; code < 16; code++) {
base_dist[code] = dist;
for (n = 0; n < (1<<extra_dbits[code]); n++) {
for (n = 0; n < (1 << extra_dbits[code]); n++) {
_dist_code[dist++] = code;
}
}
@ -433,7 +436,7 @@ function tr_static_init() {
dist >>= 7; /* from now on, all distances are divided by 128 */
for (; code < D_CODES; code++) {
base_dist[code] = dist << 7;
for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {
for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {
_dist_code[256 + dist++] = code;
}
}
@ -446,22 +449,22 @@ function tr_static_init() {
n = 0;
while (n <= 143) {
static_ltree[n*2 + 1]/*.Len*/ = 8;
static_ltree[n * 2 + 1]/*.Len*/ = 8;
n++;
bl_count[8]++;
}
while (n <= 255) {
static_ltree[n*2 + 1]/*.Len*/ = 9;
static_ltree[n * 2 + 1]/*.Len*/ = 9;
n++;
bl_count[9]++;
}
while (n <= 279) {
static_ltree[n*2 + 1]/*.Len*/ = 7;
static_ltree[n * 2 + 1]/*.Len*/ = 7;
n++;
bl_count[7]++;
}
while (n <= 287) {
static_ltree[n*2 + 1]/*.Len*/ = 8;
static_ltree[n * 2 + 1]/*.Len*/ = 8;
n++;
bl_count[8]++;
}
@ -469,18 +472,18 @@ function tr_static_init() {
* tree construction to get a canonical Huffman tree (longest code
* all ones)
*/
gen_codes(static_ltree, L_CODES+1, bl_count);
gen_codes(static_ltree, L_CODES + 1, bl_count);
/* The static distance tree is trivial: */
for (n = 0; n < D_CODES; n++) {
static_dtree[n*2 + 1]/*.Len*/ = 5;
static_dtree[n*2]/*.Code*/ = bi_reverse(n, 5);
static_dtree[n * 2 + 1]/*.Len*/ = 5;
static_dtree[n * 2]/*.Code*/ = bi_reverse(n, 5);
}
// Now data ready and we can init static trees
static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS);
static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);
static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS);
static_bl_desc =new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS);
static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS);
//static_init_done = true;
}
@ -493,11 +496,11 @@ function init_block(s) {
var n; /* iterates over tree elements */
/* Initialize the trees. */
for (n = 0; n < L_CODES; n++) { s.dyn_ltree[n*2]/*.Freq*/ = 0; }
for (n = 0; n < D_CODES; n++) { s.dyn_dtree[n*2]/*.Freq*/ = 0; }
for (n = 0; n < BL_CODES; n++) { s.bl_tree[n*2]/*.Freq*/ = 0; }
for (n = 0; n < L_CODES; n++) { s.dyn_ltree[n * 2]/*.Freq*/ = 0; }
for (n = 0; n < D_CODES; n++) { s.dyn_dtree[n * 2]/*.Freq*/ = 0; }
for (n = 0; n < BL_CODES; n++) { s.bl_tree[n * 2]/*.Freq*/ = 0; }
s.dyn_ltree[END_BLOCK*2]/*.Freq*/ = 1;
s.dyn_ltree[END_BLOCK * 2]/*.Freq*/ = 1;
s.opt_len = s.static_len = 0;
s.last_lit = s.matches = 0;
}
@ -546,8 +549,8 @@ function copy_block(s, buf, len, header)
* the subtrees have equal frequency. This minimizes the worst case length.
*/
function smaller(tree, n, m, depth) {
var _n2 = n*2;
var _m2 = m*2;
var _n2 = n * 2;
var _m2 = m * 2;
return (tree[_n2]/*.Freq*/ < tree[_m2]/*.Freq*/ ||
(tree[_n2]/*.Freq*/ === tree[_m2]/*.Freq*/ && depth[n] <= depth[m]));
}
@ -568,7 +571,7 @@ function pqdownheap(s, tree, k)
while (j <= s.heap_len) {
/* Set j to the smallest of the two sons: */
if (j < s.heap_len &&
smaller(tree, s.heap[j+1], s.heap[j], s.depth)) {
smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {
j++;
}
/* Exit if v is smaller than both sons */
@ -604,7 +607,7 @@ function compress_block(s, ltree, dtree)
if (s.last_lit !== 0) {
do {
dist = (s.pending_buf[s.d_buf + lx*2] << 8) | (s.pending_buf[s.d_buf + lx*2 + 1]);
dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | (s.pending_buf[s.d_buf + lx * 2 + 1]);
lc = s.pending_buf[s.l_buf + lx];
lx++;
@ -614,7 +617,7 @@ function compress_block(s, ltree, dtree)
} else {
/* Here, lc is the match length - MIN_MATCH */
code = _length_code[lc];
send_code(s, code+LITERALS+1, ltree); /* send the length code */
send_code(s, code + LITERALS + 1, ltree); /* send the length code */
extra = extra_lbits[code];
if (extra !== 0) {
lc -= base_length[code];
@ -676,7 +679,7 @@ function build_tree(s, desc)
s.depth[n] = 0;
} else {
tree[n*2 + 1]/*.Len*/ = 0;
tree[n * 2 + 1]/*.Len*/ = 0;
}
}
@ -692,7 +695,7 @@ function build_tree(s, desc)
s.opt_len--;
if (has_stree) {
s.static_len -= stree[node*2 + 1]/*.Len*/;
s.static_len -= stree[node * 2 + 1]/*.Len*/;
}
/* node is 0 or 1 so it does not have extra bits */
}
@ -723,7 +726,7 @@ function build_tree(s, desc)
/* Create a new node father of n and m */
tree[node * 2]/*.Freq*/ = tree[n * 2]/*.Freq*/ + tree[m * 2]/*.Freq*/;
s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
tree[n*2 + 1]/*.Dad*/ = tree[m*2 + 1]/*.Dad*/ = node;
tree[n * 2 + 1]/*.Dad*/ = tree[m * 2 + 1]/*.Dad*/ = node;
/* and insert the new node in the heap */
s.heap[1/*SMALLEST*/] = node++;
@ -756,7 +759,7 @@ function scan_tree(s, tree, max_code)
var prevlen = -1; /* last emitted length */
var curlen; /* length of current code */
var nextlen = tree[0*2 + 1]/*.Len*/; /* length of next code */
var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */
var count = 0; /* repeat count of the current code */
var max_count = 7; /* max repeat count */
@ -766,11 +769,11 @@ function scan_tree(s, tree, max_code)
max_count = 138;
min_count = 3;
}
tree[(max_code+1)*2 + 1]/*.Len*/ = 0xffff; /* guard */
tree[(max_code + 1) * 2 + 1]/*.Len*/ = 0xffff; /* guard */
for (n = 0; n <= max_code; n++) {
curlen = nextlen;
nextlen = tree[(n+1)*2 + 1]/*.Len*/;
nextlen = tree[(n + 1) * 2 + 1]/*.Len*/;
if (++count < max_count && curlen === nextlen) {
continue;
@ -781,13 +784,13 @@ function scan_tree(s, tree, max_code)
} else if (curlen !== 0) {
if (curlen !== prevlen) { s.bl_tree[curlen * 2]/*.Freq*/++; }
s.bl_tree[REP_3_6*2]/*.Freq*/++;
s.bl_tree[REP_3_6 * 2]/*.Freq*/++;
} else if (count <= 10) {
s.bl_tree[REPZ_3_10*2]/*.Freq*/++;
s.bl_tree[REPZ_3_10 * 2]/*.Freq*/++;
} else {
s.bl_tree[REPZ_11_138*2]/*.Freq*/++;
s.bl_tree[REPZ_11_138 * 2]/*.Freq*/++;
}
count = 0;
@ -822,7 +825,7 @@ function send_tree(s, tree, max_code)
var prevlen = -1; /* last emitted length */
var curlen; /* length of current code */
var nextlen = tree[0*2 + 1]/*.Len*/; /* length of next code */
var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */
var count = 0; /* repeat count of the current code */
var max_count = 7; /* max repeat count */
@ -836,7 +839,7 @@ function send_tree(s, tree, max_code)
for (n = 0; n <= max_code; n++) {
curlen = nextlen;
nextlen = tree[(n+1)*2 + 1]/*.Len*/;
nextlen = tree[(n + 1) * 2 + 1]/*.Len*/;
if (++count < max_count && curlen === nextlen) {
continue;
@ -851,15 +854,15 @@ function send_tree(s, tree, max_code)
}
//Assert(count >= 3 && count <= 6, " 3_6?");
send_code(s, REP_3_6, s.bl_tree);
send_bits(s, count-3, 2);
send_bits(s, count - 3, 2);
} else if (count <= 10) {
send_code(s, REPZ_3_10, s.bl_tree);
send_bits(s, count-3, 3);
send_bits(s, count - 3, 3);
} else {
send_code(s, REPZ_11_138, s.bl_tree);
send_bits(s, count-11, 7);
send_bits(s, count - 11, 7);
}
count = 0;
@ -901,13 +904,13 @@ function build_bl_tree(s) {
* requires that at least 4 bit length codes be sent. (appnote.txt says
* 3 but the actual value used is 4.)
*/
for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
if (s.bl_tree[bl_order[max_blindex]*2 + 1]/*.Len*/ !== 0) {
for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
if (s.bl_tree[bl_order[max_blindex] * 2 + 1]/*.Len*/ !== 0) {
break;
}
}
/* Update opt_len to include the bit length tree and counts */
s.opt_len += 3*(max_blindex+1) + 5+5+4;
s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
//Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
// s->opt_len, s->static_len));
@ -930,19 +933,19 @@ function send_all_trees(s, lcodes, dcodes, blcodes)
//Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
// "too many codes");
//Tracev((stderr, "\nbl counts: "));
send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
send_bits(s, dcodes-1, 5);
send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */
send_bits(s, lcodes - 257, 5); /* not +255 as stated in appnote.txt */
send_bits(s, dcodes - 1, 5);
send_bits(s, blcodes - 4, 4); /* not -3 as stated in appnote.txt */
for (rank = 0; rank < blcodes; rank++) {
//Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
send_bits(s, s.bl_tree[bl_order[rank]*2 + 1]/*.Len*/, 3);
send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1]/*.Len*/, 3);
}
//Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
send_tree(s, s.dyn_ltree, lcodes-1); /* literal tree */
send_tree(s, s.dyn_ltree, lcodes - 1); /* literal tree */
//Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
send_tree(s, s.dyn_dtree, dcodes-1); /* distance tree */
send_tree(s, s.dyn_dtree, dcodes - 1); /* distance tree */
//Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
}
@ -970,7 +973,7 @@ function detect_data_type(s) {
/* Check for non-textual ("black-listed") bytes. */
for (n = 0; n <= 31; n++, black_mask >>>= 1) {
if ((black_mask & 1) && (s.dyn_ltree[n*2]/*.Freq*/ !== 0)) {
if ((black_mask & 1) && (s.dyn_ltree[n * 2]/*.Freq*/ !== 0)) {
return Z_BINARY;
}
}
@ -1027,7 +1030,7 @@ function _tr_stored_block(s, buf, stored_len, last)
//ulg stored_len; /* length of input block */
//int last; /* one if this is the last block for a file */
{
send_bits(s, (STORED_BLOCK<<1)+(last ? 1 : 0), 3); /* send block type */
send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3); /* send block type */
copy_block(s, buf, stored_len, true); /* with header */
}
@ -1037,7 +1040,7 @@ function _tr_stored_block(s, buf, stored_len, last)
* This takes 10 bits, of which 7 may remain in the bit buffer.
*/
function _tr_align(s) {
send_bits(s, STATIC_TREES<<1, 3);
send_bits(s, STATIC_TREES << 1, 3);
send_code(s, END_BLOCK, static_ltree);
bi_flush(s);
}
@ -1082,8 +1085,8 @@ function _tr_flush_block(s, buf, stored_len, last)
max_blindex = build_bl_tree(s);
/* Determine the best encoding. Compute the block lengths in bytes. */
opt_lenb = (s.opt_len+3+7) >>> 3;
static_lenb = (s.static_len+3+7) >>> 3;
opt_lenb = (s.opt_len + 3 + 7) >>> 3;
static_lenb = (s.static_len + 3 + 7) >>> 3;
// Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
// opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
@ -1096,7 +1099,7 @@ function _tr_flush_block(s, buf, stored_len, last)
opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
}
if ((stored_len+4 <= opt_lenb) && (buf !== -1)) {
if ((stored_len + 4 <= opt_lenb) && (buf !== -1)) {
/* 4: two words for the lengths */
/* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
@ -1109,12 +1112,12 @@ function _tr_flush_block(s, buf, stored_len, last)
} else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {
send_bits(s, (STATIC_TREES<<1) + (last ? 1 : 0), 3);
send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);
compress_block(s, static_ltree, static_dtree);
} else {
send_bits(s, (DYN_TREES<<1) + (last ? 1 : 0), 3);
send_all_trees(s, s.l_desc.max_code+1, s.d_desc.max_code+1, max_blindex+1);
send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);
send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);
compress_block(s, s.dyn_ltree, s.dyn_dtree);
}
// Assert (s->compressed_len == s->bits_sent, "bad compressed size");
@ -1149,7 +1152,7 @@ function _tr_tally(s, dist, lc)
if (dist === 0) {
/* lc is the unmatched char */
s.dyn_ltree[lc*2]/*.Freq*/++;
s.dyn_ltree[lc * 2]/*.Freq*/++;
} else {
s.matches++;
/* Here, lc is the match length - MIN_MATCH */
@ -1158,7 +1161,7 @@ function _tr_tally(s, dist, lc)
// (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
// (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match");
s.dyn_ltree[(_length_code[lc]+LITERALS+1) * 2]/*.Freq*/++;
s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]/*.Freq*/++;
s.dyn_dtree[d_code(dist) * 2]/*.Freq*/++;
}
@ -1185,7 +1188,7 @@ function _tr_tally(s, dist, lc)
// }
//#endif
return (s.last_lit === s.lit_bufsize-1);
return (s.last_lit === s.lit_bufsize - 1);
/* We avoid equality with lit_bufsize because of wraparound at 64K
* on 16 bit machines and because stored blocks are restricted to
* 64K-1 bytes.

66
package.json
View file

@ -1,35 +1,35 @@
{
"name" : "pako",
"description" : "zlib port to javascript - fast, modularized, with browser support",
"version" : "0.2.8",
"keywords" : [ "zlib", "deflate", "inflate", "gzip" ],
"homepage" : "https://github.com/nodeca/pako",
"contributors" : [ "Andrei Tuputcyn (https://github.com/andr83)",
"Vitaly Puzrin (https://github.com/puzrin)" ],
"bugs" : { "url": "https://github.com/nodeca/pako/issues" },
"license" : { "type": "MIT", "url": "https://github.com/nodeca/pako/blob/master/LICENSE" },
"repository" : { "type": "git", "url": "git://github.com/nodeca/pako.git" },
"main" : "./index.js",
"devDependencies" : {
"mocha": "1.21.5",
"benchmark": "*",
"ansi": "*",
"browserify":"*",
"eslint": "0.17.1",
"eslint-plugin-nodeca": "~1.0.3",
"uglify-js": "*",
"istanbul": "*",
"ndoc": "*",
"lodash": "*",
"async": "*",
"grunt": "~0.4.4",
"grunt-cli": "~0.1.13",
"grunt-saucelabs": "~8.6.0",
"grunt-contrib-connect": "~0.9.0"
}
"name": "pako",
"description": "zlib port to javascript - fast, modularized, with browser support",
"version": "0.2.8",
"keywords": [
"zlib",
"deflate",
"inflate",
"gzip"
],
"homepage": "https://github.com/nodeca/pako",
"contributors": [
"Andrei Tuputcyn (https://github.com/andr83)",
"Vitaly Puzrin (https://github.com/puzrin)"
],
"license": "MIT",
"repository": "nodeca/pako",
"devDependencies": {
"mocha": "1.21.5",
"benchmark": "*",
"ansi": "*",
"browserify": "*",
"eslint": "^2.1.0",
"eslint-plugin-nodeca": "~1.0.3",
"uglify-js": "*",
"istanbul": "*",
"ndoc": "*",
"lodash": "*",
"async": "*",
"grunt": "~0.4.4",
"grunt-cli": "~0.1.13",
"grunt-saucelabs": "~8.6.0",
"grunt-contrib-connect": "~0.9.0"
}
}

4
test/chunks.js
View file

@ -29,7 +29,7 @@ function testChunk(buf, expected, packer, chunkSize) {
var onData = packer.onData;
var flushCount = 0;
packer.onData = function() {
packer.onData = function () {
flushCount++;
onData.apply(this, arguments);
};
@ -121,7 +121,7 @@ describe('Edge condition', function () {
var inflator = new pako.Inflate();
for (i = 0; i < deflated.length; i++) {
inflator.push(deflated.subarray(i, i+1), false);
inflator.push(deflated.subarray(i, i + 1), false);
assert.ok(!inflator.err, 'Inflate failed with status ' + inflator.err);
}

80
test/deflate.js
View file

@ -16,17 +16,17 @@ var samples = helpers.loadSamples();
describe('Deflate defaults', function () {
it('deflate, no options', function(done) {
it('deflate, no options', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, {}, done);
});
it('deflate raw, no options', function(done) {
it('deflate raw, no options', function (done) {
testSamples(zlib.createDeflateRaw, pako.deflateRaw, samples, {}, done);
});
// OS_CODE can differ. Probably should add param to compare function
// to ignore some buffer positions
it('gzip, no options', function(done) {
it('gzip, no options', function (done) {
testSamples(zlib.createGzip, pako.gzip, samples, {}, done);
});
});
@ -34,37 +34,37 @@ describe('Deflate defaults', function () {
describe('Deflate levels', function () {
it('level 9', function(done) {
it('level 9', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { level: 9 }, done);
});
it('level 8', function(done) {
it('level 8', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { level: 8 }, done);
});
it('level 7', function(done) {
it('level 7', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { level: 7 }, done);
});
it('level 6', function(done) {
it('level 6', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { level: 6 }, done);
});
it('level 5', function(done) {
it('level 5', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { level: 5 }, done);
});
it('level 4', function(done) {
it('level 4', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { level: 4 }, done);
});
it('level 3', function(done) {
it('level 3', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { level: 3 }, done);
});
it('level 2', function(done) {
it('level 2', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { level: 2 }, done);
});
it('level 1', function(done) {
it('level 1', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { level: 1 }, done);
});
it('level 0', function(done) {
it('level 0', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { level: 0 }, done);
});
it('level -1 (implicit default)', function(done) {
it('level -1 (implicit default)', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { level: 0 }, done);
});
});
@ -72,31 +72,31 @@ describe('Deflate levels', function () {
describe('Deflate windowBits', function () {
it('windowBits 15', function(done) {
it('windowBits 15', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { windowBits: 15 }, done);
});
it('windowBits 14', function(done) {
it('windowBits 14', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { windowBits: 14 }, done);
});
it('windowBits 13', function(done) {
it('windowBits 13', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { windowBits: 13 }, done);
});
it('windowBits 12', function(done) {
it('windowBits 12', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { windowBits: 12 }, done);
});
it('windowBits 11', function(done) {
it('windowBits 11', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { windowBits: 11 }, done);
});
it('windowBits 10', function(done) {
it('windowBits 10', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { windowBits: 10 }, done);
});
it('windowBits 9', function(done) {
it('windowBits 9', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { windowBits: 9 }, done);
});
it('windowBits 8', function(done) {
it('windowBits 8', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { windowBits: 8 }, done);
});
it('windowBits -15 (implicit raw)', function(done) {
it('windowBits -15 (implicit raw)', function (done) {
testSamples(zlib.createDeflateRaw, pako.deflate, samples, { windowBits: -15 }, done);
});
@ -105,31 +105,31 @@ describe('Deflate windowBits', function () {
describe('Deflate memLevel', function () {
it('memLevel 9', function(done) {
it('memLevel 9', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { memLevel: 9 }, done);
});
it('memLevel 8', function(done) {
it('memLevel 8', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { memLevel: 8 }, done);
});
it('memLevel 7', function(done) {
it('memLevel 7', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { memLevel: 7 }, done);
});
it('memLevel 6', function(done) {
it('memLevel 6', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { memLevel: 6 }, done);
});
it('memLevel 5', function(done) {
it('memLevel 5', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { memLevel: 5 }, done);
});
it('memLevel 4', function(done) {
it('memLevel 4', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { memLevel: 4 }, done);
});
it('memLevel 3', function(done) {
it('memLevel 3', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { memLevel: 3 }, done);
});
it('memLevel 2', function(done) {
it('memLevel 2', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { memLevel: 2 }, done);
});
it('memLevel 1', function(done) {
it('memLevel 1', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { memLevel: 1 }, done);
});
@ -138,19 +138,19 @@ describe('Deflate memLevel', function () {
describe('Deflate strategy', function () {
it('Z_DEFAULT_STRATEGY', function(done) {
it('Z_DEFAULT_STRATEGY', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { strategy: 0 }, done);
});
it('Z_FILTERED', function(done) {
it('Z_FILTERED', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { strategy: 1 }, done);
});
it('Z_HUFFMAN_ONLY', function(done) {
it('Z_HUFFMAN_ONLY', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { strategy: 2 }, done);
});
it('Z_RLE', function(done) {
it('Z_RLE', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { strategy: 3 }, done);
});
it('Z_FIXED', function(done) {
it('Z_FIXED', function (done) {
testSamples(zlib.createDeflate, pako.deflate, samples, { strategy: 4 }, done);
});
@ -159,13 +159,13 @@ describe('Deflate strategy', function () {
describe('Deflate RAW', function () {
// Since difference is only in rwapper, test for store/fast/slow methods are enougth
it('level 4', function(done) {
it('level 4', function (done) {
testSamples(zlib.createDeflateRaw, pako.deflateRaw, samples, { level: 4 }, done);
});
it('level 1', function(done) {
it('level 1', function (done) {
testSamples(zlib.createDeflateRaw, pako.deflateRaw, samples, { level: 1 }, done);
});
it('level 0', function(done) {
it('level 0', function (done) {
testSamples(zlib.createDeflateRaw, pako.deflateRaw, samples, { level: 0 }, done);
});

42
test/deflate_cover.js
View file

@ -13,7 +13,7 @@ var path = require('path');
var c = require('../lib/zlib/constants');
var msg = require('../lib/zlib/messages');
var zlib_deflate = require('../lib/zlib/deflate.js');
var zstream = require('../lib/zlib/zstream');
var ZStream = require('../lib/zlib/zstream');
var pako = require('../index');
@ -29,33 +29,33 @@ function testDeflate(data, opts, flush) {
assert.equal(deflator.err, false, msg[deflator.err]);
}
describe('Deflate support', function() {
it('stored', function() {
testDeflate(short_sample, {level: 0, chunkSize: 200}, 0);
testDeflate(short_sample, {level: 0, chunkSize: 10}, 5);
describe('Deflate support', function () {
it('stored', function () {
testDeflate(short_sample, { level: 0, chunkSize: 200 }, 0);
testDeflate(short_sample, { level: 0, chunkSize: 10 }, 5);
});
it('fast', function() {
testDeflate(short_sample, {level: 1, chunkSize: 10}, 5);
testDeflate(long_sample, {level: 1, memLevel: 1, chunkSize: 10}, 0);
it('fast', function () {
testDeflate(short_sample, { level: 1, chunkSize: 10 }, 5);
testDeflate(long_sample, { level: 1, memLevel: 1, chunkSize: 10 }, 0);
});
it('slow', function() {
testDeflate(short_sample, {level: 4, chunkSize: 10}, 5);
testDeflate(long_sample, {level: 9, memLevel: 1, chunkSize: 10}, 0);
it('slow', function () {
testDeflate(short_sample, { level: 4, chunkSize: 10 }, 5);
testDeflate(long_sample, { level: 9, memLevel: 1, chunkSize: 10 }, 0);
});
it('rle', function() {
testDeflate(short_sample, {strategy: 3}, 0);
testDeflate(short_sample, {strategy: 3, chunkSize: 10}, 5);
testDeflate(long_sample, {strategy: 3, chunkSize: 10}, 0);
it('rle', function () {
testDeflate(short_sample, { strategy: 3 }, 0);
testDeflate(short_sample, { strategy: 3, chunkSize: 10 }, 5);
testDeflate(long_sample, { strategy: 3, chunkSize: 10 }, 0);
});
it('huffman', function() {
testDeflate(short_sample, {strategy: 2}, 0);
testDeflate(short_sample, {strategy: 2, chunkSize: 10}, 5);
testDeflate(long_sample, {strategy: 2, chunkSize: 10}, 0);
it('huffman', function () {
testDeflate(short_sample, { strategy: 2 }, 0);
testDeflate(short_sample, { strategy: 2, chunkSize: 10 }, 5);
testDeflate(long_sample, { strategy: 2, chunkSize: 10 }, 0);
});
});
describe('Deflate states', function() {
describe('Deflate states', function () {
//in port checking input parameters was removed
it('inflate bad parameters', function () {
var ret, strm;
@ -63,7 +63,7 @@ describe('Deflate states', function() {
ret = zlib_deflate.deflate(null, 0);
assert(ret === c.Z_STREAM_ERROR);
strm = new zstream();
strm = new ZStream();
ret = zlib_deflate.deflateInit(null);
assert(ret === c.Z_STREAM_ERROR);

12
test/gzip_specials.js
View file

@ -18,9 +18,9 @@ function a2s(array) {
}
describe('Gzip special cases', function() {
describe('Gzip special cases', function () {
it('Read custom headers', function() {
it('Read custom headers', function () {
var data = fs.readFileSync(path.join(__dirname, 'fixtures/gzip-headers.gz'));
var inflator = new pako.Inflate();
inflator.push(data, true);
@ -30,7 +30,7 @@ describe('Gzip special cases', function() {
assert.equal(a2s(inflator.header.extra), 'test extra');
});
it('Write custom headers', function() {
it('Write custom headers', function () {
var data = ' ';
var deflator = new pako.Deflate({
@ -41,7 +41,7 @@ describe('Gzip special cases', function() {
os: 15,
name: 'test name',
comment: 'test comment',
extra: [4,5,6]
extra: [ 4, 5, 6 ]
}
});
deflator.push(data, true);
@ -57,10 +57,10 @@ describe('Gzip special cases', function() {
assert.equal(header.os, 15);
assert.equal(header.name, 'test name');
assert.equal(header.comment, 'test comment');
assert(cmp(header.extra, [4,5,6]));
assert(cmp(header.extra, [ 4, 5, 6 ]));
});
it('Read stream with SYNC marks', function() {
it('Read stream with SYNC marks', function () {
var inflator, strm, _in, len, pos = 0, i = 0;
var data = fs.readFileSync(path.join(__dirname, 'fixtures/gzip-joined.gz'));

15
test/helpers.js
View file

@ -38,7 +38,7 @@ function cmpBuf(a, b) {
return false;
}
for (var i=0, l=a.length; i<l; i++) {
for (var i = 0, l = a.length; i < l; i++) {
if (a[i] !== b[i]) {
//console.log('pos: ' +i+ ' - ' + a[i].toString(16) + '/' + b[i].toString(16));
return false;
@ -63,20 +63,20 @@ function testSingle(zlib_factory, pako_deflate, data, options, callback) {
var buffers = [], nread = 0;
zlibStream.on('error', function(err) {
zlibStream.on('error', function (err) {
zlibStream.removeAllListeners();
zlibStream=null;
zlibStream = null;
callback(err);
});
zlibStream.on('data', function(chunk) {
zlibStream.on('data', function (chunk) {
buffers.push(chunk);
nread += chunk.length;
});
zlibStream.on('end', function() {
zlibStream.on('end', function () {
zlibStream.removeAllListeners();
zlibStream=null;
zlibStream = null;
var buffer = Buffer.concat(buffers);
@ -98,7 +98,7 @@ function testSingle(zlib_factory, pako_deflate, data, options, callback) {
function testSamples(zlib_factory, pako_deflate, samples, options, callback) {
var queue = [];
_.forEach(samples, function(data, name) {
_.forEach(samples, function (data, name) {
// with untyped arrays
queue.push(function (done) {
pako_utils.setTyped(false);
@ -136,6 +136,7 @@ function testInflate(samples, inflateOptions, deflateOptions, callback) {
// inflate options have windowBits = 0 to force autodetect window size
//
for (name in samples) {
if (!samples.hasOwnProperty(name)) continue;
data = samples[name];
// always use the same data type to generate sample

76
test/inflate.js
View file

@ -16,15 +16,15 @@ var samples = helpers.loadSamples();
describe('Inflate defaults', function () {
it('inflate, no options', function(done) {
it('inflate, no options', function (done) {
testInflate(samples, {}, {}, done);
});
it('inflate raw, no options', function(done) {
it('inflate raw, no options', function (done) {
testInflate(samples, { raw: true }, { raw: true }, done);
});
it('inflate raw from compressed samples', function(done) {
it('inflate raw from compressed samples', function (done) {
var compressed_samples = helpers.loadSamples('samples_deflated_raw');
helpers.testSamples(zlib.createInflateRaw, pako.inflateRaw, compressed_samples, {}, done);
});
@ -32,11 +32,11 @@ describe('Inflate defaults', function () {
describe('Inflate ungzip', function () {
it('with autodetect', function(done) {
it('with autodetect', function (done) {
testInflate(samples, {}, { gzip: true }, done);
});
it('with method set directly', function(done) {
it('with method set directly', function (done) {
testInflate(samples, { windowBits: 16 }, { gzip: true }, done);
});
});
@ -44,34 +44,34 @@ describe('Inflate ungzip', function () {
describe('Inflate levels', function () {
it('level 9', function(done) {
it('level 9', function (done) {
testInflate(samples, {}, { level: 9 }, done);
});
it('level 8', function(done) {
it('level 8', function (done) {
testInflate(samples, {}, { level: 8 }, done);
});
it('level 7', function(done) {
it('level 7', function (done) {
testInflate(samples, {}, { level: 7 }, done);
});
it('level 6', function(done) {
it('level 6', function (done) {
testInflate(samples, {}, { level: 6 }, done);
});
it('level 5', function(done) {
it('level 5', function (done) {
testInflate(samples, {}, { level: 5 }, done);
});
it('level 4', function(done) {
it('level 4', function (done) {
testInflate(samples, {}, { level: 4 }, done);
});
it('level 3', function(done) {
it('level 3', function (done) {
testInflate(samples, {}, { level: 3 }, done);
});
it('level 2', function(done) {
it('level 2', function (done) {
testInflate(samples, {}, { level: 2 }, done);
});
it('level 1', function(done) {
it('level 1', function (done) {
testInflate(samples, {}, { level: 1 }, done);
});
it('level 0', function(done) {
it('level 0', function (done) {
testInflate(samples, {}, { level: 0 }, done);
});
@ -80,28 +80,28 @@ describe('Inflate levels', function () {
describe('Inflate windowBits', function () {
it('windowBits 15', function(done) {
it('windowBits 15', function (done) {
testInflate(samples, {}, { windowBits: 15 }, done);
});
it('windowBits 14', function(done) {
it('windowBits 14', function (done) {
testInflate(samples, {}, { windowBits: 14 }, done);
});
it('windowBits 13', function(done) {
it('windowBits 13', function (done) {
testInflate(samples, {}, { windowBits: 13 }, done);
});
it('windowBits 12', function(done) {
it('windowBits 12', function (done) {
testInflate(samples, {}, { windowBits: 12 }, done);
});
it('windowBits 11', function(done) {
it('windowBits 11', function (done) {
testInflate(samples, {}, { windowBits: 11 }, done);
});
it('windowBits 10', function(done) {
it('windowBits 10', function (done) {
testInflate(samples, {}, { windowBits: 10 }, done);
});
it('windowBits 9', function(done) {
it('windowBits 9', function (done) {
testInflate(samples, {}, { windowBits: 9 }, done);
});
it('windowBits 8', function(done) {
it('windowBits 8', function (done) {
testInflate(samples, {}, { windowBits: 8 }, done);
});
@ -109,19 +109,19 @@ describe('Inflate windowBits', function () {
describe('Inflate strategy', function () {
it('Z_DEFAULT_STRATEGY', function(done) {
it('Z_DEFAULT_STRATEGY', function (done) {
testInflate(samples, {}, { strategy: 0 }, done);
});
it('Z_FILTERED', function(done) {
it('Z_FILTERED', function (done) {
testInflate(samples, {}, { strategy: 1 }, done);
});
it('Z_HUFFMAN_ONLY', function(done) {
it('Z_HUFFMAN_ONLY', function (done) {
testInflate(samples, {}, { strategy: 2 }, done);
});
it('Z_RLE', function(done) {
it('Z_RLE', function (done) {
testInflate(samples, {}, { strategy: 3 }, done);
});
it('Z_FIXED', function(done) {
it('Z_FIXED', function (done) {
testInflate(samples, {}, { strategy: 4 }, done);
});
@ -130,34 +130,34 @@ describe('Inflate strategy', function () {
describe('Inflate RAW', function () {
// Since difference is only in rwapper, test for store/fast/slow methods are enougth
it('level 9', function(done) {
it('level 9', function (done) {
testInflate(samples, { raw: true }, { level: 9, raw: true }, done);
});
it('level 8', function(done) {
it('level 8', function (done) {
testInflate(samples, { raw: true }, { level: 8, raw: true }, done);
});
it('level 7', function(done) {
it('level 7', function (done) {
testInflate(samples, { raw: true }, { level: 7, raw: true }, done);
});
it('level 6', function(done) {
it('level 6', function (done) {
testInflate(samples, { raw: true }, { level: 6, raw: true }, done);
});
it('level 5', function(done) {
it('level 5', function (done) {
testInflate(samples, { raw: true }, { level: 5, raw: true }, done);
});
it('level 4', function(done) {
it('level 4', function (done) {
testInflate(samples, { raw: true }, { level: 4, raw: true }, done);
});
it('level 3', function(done) {
it('level 3', function (done) {
testInflate(samples, { raw: true }, { level: 3, raw: true }, done);
});
it('level 2', function(done) {
it('level 2', function (done) {
testInflate(samples, { raw: true }, { level: 2, raw: true }, done);
});
it('level 1', function(done) {
it('level 1', function (done) {
testInflate(samples, { raw: true }, { level: 1, raw: true }, done);
});
it('level 0', function(done) {
it('level 0', function (done) {
testInflate(samples, { raw: true }, { level: 0, raw: true }, done);
});

112
test/inflate_cover_ported.js
View file

@ -18,7 +18,7 @@ var pako = require('../index');
function h2b(hex) {
return hex.split(' ').map(function(hx) { return parseInt(hx, 16); });
return hex.split(' ').map(function (hx) { return parseInt(hx, 16); });
}
@ -27,7 +27,7 @@ function h2b(hex) {
function testInflate(hex, wbits, status) {
var inflator;
try {
inflator= new pako.Inflate({ windowBits: wbits });
inflator = new pako.Inflate({ windowBits: wbits });
} catch (e) {
assert(e === msg[status]);
return;
@ -37,9 +37,9 @@ function testInflate(hex, wbits, status) {
}
describe('Inflate states', function() {
describe('Inflate states', function () {
//in port checking input parameters was removed
it('inflate bad parameters', function() {
it('inflate bad parameters', function () {
var ret;
ret = zlib_inflate.inflate(null, 0);
@ -52,113 +52,113 @@ describe('Inflate states', function() {
//ret = zlib_inflate.inflateCopy(null, null);
//assert(ret == c.Z_STREAM_ERROR);
});
it('bad gzip method', function() {
it('bad gzip method', function () {
testInflate('1f 8b 0 0', 31, c.Z_DATA_ERROR);
});
it('bad gzip flags', function() {
it('bad gzip flags', function () {
testInflate('1f 8b 8 80', 31, c.Z_DATA_ERROR);
});
it('bad zlib method', function() {
it('bad zlib method', function () {
testInflate('77 85', 15, c.Z_DATA_ERROR);
});
it('set window size from header', function() {
it('set window size from header', function () {
testInflate('8 99', 0, c.Z_OK);
});
it('bad zlib window size', function() {
it('bad zlib window size', function () {
testInflate('78 9c', 8, c.Z_DATA_ERROR);
});
it('check adler32', function() {
it('check adler32', function () {
testInflate('78 9c 63 0 0 0 1 0 1', 15, c.Z_OK);
});
it('bad header crc', function() {
it('bad header crc', function () {
testInflate('1f 8b 8 1e 0 0 0 0 0 0 1 0 0 0 0 0 0', 47, c.Z_DATA_ERROR);
});
it('check gzip length', function() {
it('check gzip length', function () {
testInflate('1f 8b 8 2 0 0 0 0 0 0 1d 26 3 0 0 0 0 0 0 0 0 0', 47, c.Z_OK);
});
it('bad zlib header check', function() {
it('bad zlib header check', function () {
testInflate('78 90', 47, c.Z_DATA_ERROR);
});
it('need dictionary', function() {
it('need dictionary', function () {
testInflate('8 b8 0 0 0 1', 8, c.Z_NEED_DICT);
});
it('compute adler32', function() {
it('compute adler32', function () {
testInflate('78 9c 63 0', 15, c.Z_OK);
});
});
describe('Inflate cover', function() {
it('invalid stored block lengths', function() {
describe('Inflate cover', function () {
it('invalid stored block lengths', function () {
testInflate('0 0 0 0 0', -15, c.Z_DATA_ERROR);
});
it('fixed', function() {
it('fixed', function () {
testInflate('3 0', -15, c.Z_OK);
});
it('invalid block type', function() {
it('invalid block type', function () {
testInflate('6', -15, c.Z_DATA_ERROR);
});
it('stored', function() {
it('stored', function () {
testInflate('1 1 0 fe ff 0', -15, c.Z_OK);
});
it('too many length or distance symbols', function() {
it('too many length or distance symbols', function () {
testInflate('fc 0 0', -15, c.Z_DATA_ERROR);
});
it('invalid code lengths set', function() {
it('invalid code lengths set', function () {
testInflate('4 0 fe ff', -15, c.Z_DATA_ERROR);
});
it('invalid bit length repeat', function() {
it('invalid bit length repeat', function () {
testInflate('4 0 24 49 0', -15, c.Z_DATA_ERROR);
});
it('invalid bit length repeat', function() {
it('invalid bit length repeat', function () {
testInflate('4 0 24 e9 ff ff', -15, c.Z_DATA_ERROR);
});
it('invalid code -- missing end-of-block', function() {
it('invalid code -- missing end-of-block', function () {
testInflate('4 0 24 e9 ff 6d', -15, c.Z_DATA_ERROR);
});
it('invalid literal/lengths set', function() {
it('invalid literal/lengths set', function () {
testInflate('4 80 49 92 24 49 92 24 71 ff ff 93 11 0', -15, c.Z_DATA_ERROR);
});
it('invalid literal/length code', function() {
it('invalid literal/length code', function () {
testInflate('4 80 49 92 24 49 92 24 f b4 ff ff c3 84', -15, c.Z_DATA_ERROR);
});
it('invalid distance code', function() {
it('invalid distance code', function () {
testInflate('2 7e ff ff', -15, c.Z_DATA_ERROR);
});
it('invalid distance too far back', function() {
it('invalid distance too far back', function () {
testInflate('c c0 81 0 0 0 0 0 90 ff 6b 4 0', -15, c.Z_DATA_ERROR);
});
it('incorrect data check', function() {
it('incorrect data check', function () {
testInflate('1f 8b 8 0 0 0 0 0 0 0 3 0 0 0 0 1', 47, c.Z_DATA_ERROR);
});
it('incorrect length check', function() {
it('incorrect length check', function () {
testInflate('1f 8b 8 0 0 0 0 0 0 0 3 0 0 0 0 0 0 0 0 1', 47, c.Z_DATA_ERROR);
});
it('pull 17', function() {
it('pull 17', function () {
testInflate('5 c0 21 d 0 0 0 80 b0 fe 6d 2f 91 6c', -15, c.Z_OK);
});
it('long code', function() {
it('long code', function () {
testInflate('5 e0 81 91 24 cb b2 2c 49 e2 f 2e 8b 9a 47 56 9f fb fe ec d2 ff 1f', -15, c.Z_OK);
});
it('length extra', function() {
it('length extra', function () {
testInflate('ed c0 1 1 0 0 0 40 20 ff 57 1b 42 2c 4f', -15, c.Z_OK);
});
it('long distance and extra', function() {
it('long distance and extra', function () {
testInflate('ed cf c1 b1 2c 47 10 c4 30 fa 6f 35 1d 1 82 59 3d fb be 2e 2a fc f c', -15, c.Z_OK);
});
it('window end', function() {
it('window end', function () {
testInflate('ed c0 81 0 0 0 0 80 a0 fd a9 17 a9 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6',
-15, c.Z_OK);
});
it('inflate_fast TYPE return', function() {
it('inflate_fast TYPE return', function () {
testInflate('2 8 20 80 0 3 0', -15, c.Z_OK);
});
it('window wrap', function() {
it('window wrap', function () {
testInflate('63 18 5 40 c 0', -8, c.Z_OK);
});
});
describe('cover trees', function() {
it('inflate_table not enough errors', function() {
describe('cover trees', function () {
it('inflate_table not enough errors', function () {
var ret, bits, next, table = [], lens = [], work = [];
var DISTS = 2;
/* we need to call inflate_table() directly in order to manifest not-
@ -169,42 +169,42 @@ describe('cover trees', function() {
lens[15] = 15;
next = table;
ret = inflate_table(DISTS, lens, 0, 16, next, 0, work, {bits: 15});
ret = inflate_table(DISTS, lens, 0, 16, next, 0, work, { bits: 15 });
assert(ret === 1);
next = table;
ret = inflate_table(DISTS, lens, 0, 16, next, 0, work, {bits: 1});
ret = inflate_table(DISTS, lens, 0, 16, next, 0, work, { bits: 1 });
assert(ret === 1);
});
});
describe('Inflate fast', function() {
it('fast length extra bits', function() {
describe('Inflate fast', function () {
it('fast length extra bits', function () {
testInflate('e5 e0 81 ad 6d cb b2 2c c9 01 1e 59 63 ae 7d ee fb 4d fd b5 35 41 68' +
' ff 7f 0f 0 0 0', -8, c.Z_DATA_ERROR);
});
it('fast distance extra bits', function() {
it('fast distance extra bits', function () {
testInflate('25 fd 81 b5 6d 59 b6 6a 49 ea af 35 6 34 eb 8c b9 f6 b9 1e ef 67 49' +
' 50 fe ff ff 3f 0 0', -8, c.Z_DATA_ERROR);
});
it('fast invalid literal/length code', function() {
it('fast invalid literal/length code', function () {
testInflate('1b 7 0 0 0 0 0', -8, c.Z_DATA_ERROR);
});
it('fast 2nd level codes and too far back', function() {
it('fast 2nd level codes and too far back', function () {
testInflate('d c7 1 ae eb 38 c 4 41 a0 87 72 de df fb 1f b8 36 b1 38 5d ff ff 0', -8, c.Z_DATA_ERROR);
});
it('very common case', function() {
it('very common case', function () {
testInflate('63 18 5 8c 10 8 0 0 0 0', -8, c.Z_OK);
});
it('contiguous and wrap around window', function() {
it('contiguous and wrap around window', function () {
testInflate('63 60 60 18 c9 0 8 18 18 18 26 c0 28 0 29 0 0 0', -8, c.Z_OK);
});
it('copy direct from output', function() {
it('copy direct from output', function () {
testInflate('63 0 3 0 0 0 0 0', -8, c.Z_OK);
});
});
describe('Inflate support', function() {
describe('Inflate support', function () {
// `inflatePrime` not implemented
/*it('prime', function() {
var ret;
@ -228,19 +228,19 @@ describe('Inflate support', function() {
ret = zlib_inflate.inflateEnd(strm);
assert(ret === c.Z_OK);
});*/
it('force window allocation', function() {
it('force window allocation', function () {
testInflate('63 0', -15, c.Z_OK);
});
it('force window replacement', function() {
it('force window replacement', function () {
testInflate('63 18 5', -15, c.Z_OK);
});
it('force split window update', function() {
it('force split window update', function () {
testInflate('63 18 68 30 d0 0 0', -15, c.Z_OK);
});
it('use fixed blocks', function() {
it('use fixed blocks', function () {
testInflate('3 0', -15, c.Z_OK);
});
it('bad window size', function() {
it('bad window size', function () {
testInflate('', -15, c.Z_OK);
});
});

2
test/strings.js
View file

@ -40,7 +40,7 @@ function a2utf16(arr) {
describe('Encode/Decode', function () {
// Create sample, that contains all types of utf8 (1-4byte) after conversion
var utf16sample = a2utf16([0x1f3b5, 'a', 0x266a, 0x35, 0xe800, 0x10ffff, 0x0fffff]);
var utf16sample = a2utf16([ 0x1f3b5, 'a', 0x266a, 0x35, 0xe800, 0x10ffff, 0x0fffff ]);
// use node Buffer internal conversion as "done right"
var utf8sample = new Uint8Array(new Buffer(utf16sample));