diff --git a/.npmignore b/.npmignore
index 5c5f13e..e5951ea 100644
--- a/.npmignore
+++ b/.npmignore
@@ -6,4 +6,6 @@ test/
jest.config.js
yarn.lock
yarn-error.log
-/diagram.png
\ No newline at end of file
+/diagram.png
+.prettierignore
+.prettierrc
\ No newline at end of file
diff --git a/.prettierignore b/.prettierignore
new file mode 100644
index 0000000..8d87b1d
--- /dev/null
+++ b/.prettierignore
@@ -0,0 +1 @@
+node_modules/*
diff --git a/.prettierrc b/.prettierrc
new file mode 100644
index 0000000..e69de29
diff --git a/README.md b/README.md
index 014b059..8e8cdeb 100644
--- a/README.md
+++ b/README.md
@@ -7,6 +7,7 @@ plantuml to an inline dataurl png ```![]()
```
* [eleventy](https://www.npmjs.com/package/@11ty/eleventy) A simpler static site generator for which this plugin is make.
* [sync-request](https://www.npmjs.com/package/sync-request) (for making blocking synchronous http request - not to be used in production)
* [jest](https://www.npmjs.com/package/jest) (for executing unit tests)
+* [prettier](https://www.npmjs.com/package/prettier) (for keeping things clean and tidy)
## Installation
@@ -58,15 +59,17 @@ plugin -> MDH: img src="dataurl"
`` `
```
-The result is the following image inserted (inline) in the generated html site
+The result is an image inserted (inline) in the generated html site (click to open)
-
+[Sequence diagram](https://github.com/awaragi/eleventy-plugin-plantuml/blob/master/diagram.png)
## Contribute
* create a fork of this repo
* make your changes
+* run prettier for code format consistency
* test your code by running ```yarn test``` or ```npm test```
* create a Pull Request
+* Send me an email in case I miss the PR notification
## Testing
diff --git a/index.js b/index.js
index 4f35b5c..4c79341 100644
--- a/index.js
+++ b/index.js
@@ -1 +1 @@
-module.exports = require('./lib/eleventy-plugin-plantuml');
\ No newline at end of file
+module.exports = { plugin: require('./lib/eleventy-plugin-plantuml')};
\ No newline at end of file
diff --git a/lib/eleventy-plugin-plantuml.js b/lib/eleventy-plugin-plantuml.js
index 35aec61..f9f723c 100644
--- a/lib/eleventy-plugin-plantuml.js
+++ b/lib/eleventy-plugin-plantuml.js
@@ -1,69 +1,71 @@
-const request = require('sync-request');
-const plantumlEncode = require('./plantumlEncode');
+const request = require("sync-request");
+const plantumlEncode = require("./plantumlEncode");
const defaultOptions = {
- protocol: 'http',
- hostname: 'www.plantuml.com',
- port: "80",
- prefix: "/plantuml",
- outputType: "png",
- imgClass: "plantuml"
+ protocol: "http",
+ hostname: "www.plantuml.com",
+ port: "80",
+ prefix: "/plantuml",
+ outputType: "png",
+ imgClass: "plantuml",
};
function generatePlantumlUrl(encoded, options) {
- return `${options.protocol}://${options.hostname}${options.port === 80 ? "" : options.port === 443 ? "" : (":" + options.port)}${options.prefix}/${options.outputType}/${encoded}`;
+ return `${options.protocol}://${options.hostname}${
+ options.port === 80 ? "" : options.port === 443 ? "" : ":" + options.port
+ }${options.prefix}/${options.outputType}/${encoded}`;
}
const generateImageAsBase64String = (url, options) => {
- // request url
- const response = request('GET', url);
- // convert from Uint8Array to buffer to base64 string
- return Buffer.from(response.getBody()).toString('base64');
-}
+ // request url
+ const response = request("GET", url);
+ // convert from Uint8Array to buffer to base64 string
+ return Buffer.from(response.getBody()).toString("base64");
+};
const generateImgTag = (imageBase64, options) => {
- return `
`;
+ return ``;
};
const highlight = (diagram, options) => {
- // compute compressed version of str
- const encoded = plantumlEncode(diagram);
- // URL to send to plantuml for conversion
- const url = generatePlantumlUrl(encoded, options);
- // Call plantuml server to generate image
- const imageBase64 = generateImageAsBase64String(url, options);
- // Finally convert image to dataurl
- return generateImgTag(imageBase64, options);
+ // compute compressed version of str
+ const encoded = plantumlEncode(diagram);
+ // URL to send to plantuml for conversion
+ const url = generatePlantumlUrl(encoded, options);
+ // Call plantuml server to generate image
+ const imageBase64 = generateImageAsBase64String(url, options);
+ // Finally convert image to dataurl
+ return generateImgTag(imageBase64, options);
};
const plugin = (eleventyConfig, pluginOptions = {}) => {
- // default options
- const options = Object.assign({}, defaultOptions, pluginOptions);
+ // default options
+ const options = Object.assign({}, defaultOptions, pluginOptions);
- // preserve chain of highlighter
- const highlighter = eleventyConfig.markdownHighlighter;
+ // preserve chain of highlighter
+ const highlighter = eleventyConfig.markdownHighlighter;
- // add highlighter
- eleventyConfig.addMarkdownHighlighter((diagram, language) => {
- if (language === "plantuml") {
- return highlight(diagram, options);
- }
- // just in case highlighter is not enabled in which case I am not sure why we are doing
- if (highlighter) {
- return highlighter(diagram, language)
- }
- // default highlighter just in case
- return `${diagram}`;
- });
- return {}
+ // add highlighter
+ eleventyConfig.addMarkdownHighlighter((diagram, language) => {
+ if (language === "plantuml") {
+ return highlight(diagram, options);
+ }
+ // just in case highlighter is not enabled in which case I am not sure why we are doing
+ if (highlighter) {
+ return highlighter(diagram, language);
+ }
+ // default highlighter just in case
+ return `${diagram}`;
+ });
+ return {};
};
module.exports = {
- defaultOptions,
- plugin,
- highlight,
-
- generatePlantumlUrl,
- generateImageAsBase64String,
- generateImgTag
-};
\ No newline at end of file
+ defaultOptions,
+ plugin,
+ highlight,
+
+ generatePlantumlUrl,
+ generateImageAsBase64String,
+ generateImgTag,
+};
diff --git a/lib/plantumlEncode.js b/lib/plantumlEncode.js
index c504cf3..355dad3 100644
--- a/lib/plantumlEncode.js
+++ b/lib/plantumlEncode.js
@@ -2,57 +2,60 @@
* Original:
* https://github.com/johan/js-deflate
*/
-const { deflate } = require('./rawdeflate');
+const { deflate } = require("./rawdeflate");
-const encode64 = data => {
- let r = "";
- for (let i=0; i {
+ let r = "";
+ for (let i = 0; i < data.length; i += 3) {
+ if (i + 2 === data.length) {
+ r += append3bytes(data.charCodeAt(i), data.charCodeAt(i + 1), 0);
+ } else if (i + 1 === data.length) {
+ r += append3bytes(data.charCodeAt(i), 0, 0);
+ } else {
+ r += append3bytes(
+ data.charCodeAt(i),
+ data.charCodeAt(i + 1),
+ data.charCodeAt(i + 2)
+ );
}
- return r;
-}
+ }
+ return r;
+};
const append3bytes = (b1, b2, b3) => {
- let c1 = b1 >> 2;
- let c2 = ((b1 & 0x3) << 4) | (b2 >> 4);
- let c3 = ((b2 & 0xF) << 2) | (b3 >> 6);
- let c4 = b3 & 0x3F;
- let r = "";
- r += encode6bit(c1 & 0x3F);
- r += encode6bit(c2 & 0x3F);
- r += encode6bit(c3 & 0x3F);
- r += encode6bit(c4 & 0x3F);
- return r;
-}
+ let c1 = b1 >> 2;
+ let c2 = ((b1 & 0x3) << 4) | (b2 >> 4);
+ let c3 = ((b2 & 0xf) << 2) | (b3 >> 6);
+ let c4 = b3 & 0x3f;
+ let r = "";
+ r += encode6bit(c1 & 0x3f);
+ r += encode6bit(c2 & 0x3f);
+ r += encode6bit(c3 & 0x3f);
+ r += encode6bit(c4 & 0x3f);
+ return r;
+};
-const encode6bit = b => {
- if (b < 10) {
- return String.fromCharCode(48 + b);
- }
- b -= 10;
- if (b < 26) {
- return String.fromCharCode(65 + b);
- }
- b -= 26;
- if (b < 26) {
- return String.fromCharCode(97 + b);
- }
- b -= 26;
- if (b === 0) {
- return '-';
- }
- if (b === 1) {
- return '_';
- }
- return '?';
-}
+const encode6bit = (b) => {
+ if (b < 10) {
+ return String.fromCharCode(48 + b);
+ }
+ b -= 10;
+ if (b < 26) {
+ return String.fromCharCode(65 + b);
+ }
+ b -= 26;
+ if (b < 26) {
+ return String.fromCharCode(97 + b);
+ }
+ b -= 26;
+ if (b === 0) {
+ return "-";
+ }
+ if (b === 1) {
+ return "_";
+ }
+ return "?";
+};
const geturl = (s) => encode64(deflate(unescape(encodeURIComponent(s)), 9));
-module.exports = geturl;
\ No newline at end of file
+module.exports = geturl;
diff --git a/lib/rawdeflate.js b/lib/rawdeflate.js
index c8e8da2..2904d43 100644
--- a/lib/rawdeflate.js
+++ b/lib/rawdeflate.js
@@ -4,205 +4,208 @@
*/
// if run as a web worker, respond to messages by deflating them
-var deflate = (function() {
-
-/* Copyright (C) 1999 Masanao Izumo
- * Version: 1.0.1
- * LastModified: Dec 25 1999
- */
+var deflate = (function () {
+ /* Copyright (C) 1999 Masanao Izumo
+ * Version: 1.0.1
+ * LastModified: Dec 25 1999
+ */
-/* Interface:
- * data = deflate(src);
- */
+ /* Interface:
+ * data = deflate(src);
+ */
-/* constant parameters */
-var zip_WSIZE = 32768; // Sliding Window size
-var zip_STORED_BLOCK = 0;
-var zip_STATIC_TREES = 1;
-var zip_DYN_TREES = 2;
-
-/* for deflate */
-var zip_DEFAULT_LEVEL = 6;
-var zip_FULL_SEARCH = true;
-var zip_INBUFSIZ = 32768; // Input buffer size
-var zip_INBUF_EXTRA = 64; // Extra buffer
-var zip_OUTBUFSIZ = 1024 * 8;
-var zip_window_size = 2 * zip_WSIZE;
-var zip_MIN_MATCH = 3;
-var zip_MAX_MATCH = 258;
-var zip_BITS = 16;
-// for SMALL_MEM
-var zip_LIT_BUFSIZE = 0x2000;
-var zip_HASH_BITS = 13;
-// for MEDIUM_MEM
-// var zip_LIT_BUFSIZE = 0x4000;
-// var zip_HASH_BITS = 14;
-// for BIG_MEM
-// var zip_LIT_BUFSIZE = 0x8000;
-// var zip_HASH_BITS = 15;
-//if(zip_LIT_BUFSIZE > zip_INBUFSIZ)
-// alert("error: zip_INBUFSIZ is too small");
-//if((zip_WSIZE<<1) > (1< zip_BITS-1)
-// alert("error: zip_HASH_BITS is too large");
-//if(zip_HASH_BITS < 8 || zip_MAX_MATCH != 258)
-// alert("error: Code too clever");
-var zip_DIST_BUFSIZE = zip_LIT_BUFSIZE;
-var zip_HASH_SIZE = 1 << zip_HASH_BITS;
-var zip_HASH_MASK = zip_HASH_SIZE - 1;
-var zip_WMASK = zip_WSIZE - 1;
-var zip_NIL = 0; // Tail of hash chains
-var zip_TOO_FAR = 4096;
-var zip_MIN_LOOKAHEAD = zip_MAX_MATCH + zip_MIN_MATCH + 1;
-var zip_MAX_DIST = zip_WSIZE - zip_MIN_LOOKAHEAD;
-var zip_SMALLEST = 1;
-var zip_MAX_BITS = 15;
-var zip_MAX_BL_BITS = 7;
-var zip_LENGTH_CODES = 29;
-var zip_LITERALS =256;
-var zip_END_BLOCK = 256;
-var zip_L_CODES = zip_LITERALS + 1 + zip_LENGTH_CODES;
-var zip_D_CODES = 30;
-var zip_BL_CODES = 19;
-var zip_REP_3_6 = 16;
-var zip_REPZ_3_10 = 17;
-var zip_REPZ_11_138 = 18;
-var zip_HEAP_SIZE = 2 * zip_L_CODES + 1;
-var zip_H_SHIFT = parseInt((zip_HASH_BITS + zip_MIN_MATCH - 1) /
- zip_MIN_MATCH);
-
-/* variables */
-var zip_free_queue;
-var zip_qhead, zip_qtail;
-var zip_initflag;
-var zip_outbuf = null;
-var zip_outcnt, zip_outoff;
-var zip_complete;
-var zip_window;
-var zip_d_buf;
-var zip_l_buf;
-var zip_prev;
-var zip_bi_buf;
-var zip_bi_valid;
-var zip_block_start;
-var zip_ins_h;
-var zip_hash_head;
-var zip_prev_match;
-var zip_match_available;
-var zip_match_length;
-var zip_prev_length;
-var zip_strstart;
-var zip_match_start;
-var zip_eofile;
-var zip_lookahead;
-var zip_max_chain_length;
-var zip_max_lazy_match;
-var zip_compr_level;
-var zip_good_match;
-var zip_nice_match;
-var zip_dyn_ltree;
-var zip_dyn_dtree;
-var zip_static_ltree;
-var zip_static_dtree;
-var zip_bl_tree;
-var zip_l_desc;
-var zip_d_desc;
-var zip_bl_desc;
-var zip_bl_count;
-var zip_heap;
-var zip_heap_len;
-var zip_heap_max;
-var zip_depth;
-var zip_length_code;
-var zip_dist_code;
-var zip_base_length;
-var zip_base_dist;
-var zip_flag_buf;
-var zip_last_lit;
-var zip_last_dist;
-var zip_last_flags;
-var zip_flags;
-var zip_flag_bit;
-var zip_opt_len;
-var zip_static_len;
-var zip_deflate_data;
-var zip_deflate_pos;
-
-/* objects (deflate) */
-
-function zip_DeflateCT() {
+ /* constant parameters */
+ var zip_WSIZE = 32768; // Sliding Window size
+ var zip_STORED_BLOCK = 0;
+ var zip_STATIC_TREES = 1;
+ var zip_DYN_TREES = 2;
+
+ /* for deflate */
+ var zip_DEFAULT_LEVEL = 6;
+ var zip_FULL_SEARCH = true;
+ var zip_INBUFSIZ = 32768; // Input buffer size
+ var zip_INBUF_EXTRA = 64; // Extra buffer
+ var zip_OUTBUFSIZ = 1024 * 8;
+ var zip_window_size = 2 * zip_WSIZE;
+ var zip_MIN_MATCH = 3;
+ var zip_MAX_MATCH = 258;
+ var zip_BITS = 16;
+ // for SMALL_MEM
+ var zip_LIT_BUFSIZE = 0x2000;
+ var zip_HASH_BITS = 13;
+ // for MEDIUM_MEM
+ // var zip_LIT_BUFSIZE = 0x4000;
+ // var zip_HASH_BITS = 14;
+ // for BIG_MEM
+ // var zip_LIT_BUFSIZE = 0x8000;
+ // var zip_HASH_BITS = 15;
+ //if(zip_LIT_BUFSIZE > zip_INBUFSIZ)
+ // alert("error: zip_INBUFSIZ is too small");
+ //if((zip_WSIZE<<1) > (1< zip_BITS-1)
+ // alert("error: zip_HASH_BITS is too large");
+ //if(zip_HASH_BITS < 8 || zip_MAX_MATCH != 258)
+ // alert("error: Code too clever");
+ var zip_DIST_BUFSIZE = zip_LIT_BUFSIZE;
+ var zip_HASH_SIZE = 1 << zip_HASH_BITS;
+ var zip_HASH_MASK = zip_HASH_SIZE - 1;
+ var zip_WMASK = zip_WSIZE - 1;
+ var zip_NIL = 0; // Tail of hash chains
+ var zip_TOO_FAR = 4096;
+ var zip_MIN_LOOKAHEAD = zip_MAX_MATCH + zip_MIN_MATCH + 1;
+ var zip_MAX_DIST = zip_WSIZE - zip_MIN_LOOKAHEAD;
+ var zip_SMALLEST = 1;
+ var zip_MAX_BITS = 15;
+ var zip_MAX_BL_BITS = 7;
+ var zip_LENGTH_CODES = 29;
+ var zip_LITERALS = 256;
+ var zip_END_BLOCK = 256;
+ var zip_L_CODES = zip_LITERALS + 1 + zip_LENGTH_CODES;
+ var zip_D_CODES = 30;
+ var zip_BL_CODES = 19;
+ var zip_REP_3_6 = 16;
+ var zip_REPZ_3_10 = 17;
+ var zip_REPZ_11_138 = 18;
+ var zip_HEAP_SIZE = 2 * zip_L_CODES + 1;
+ var zip_H_SHIFT = parseInt(
+ (zip_HASH_BITS + zip_MIN_MATCH - 1) / zip_MIN_MATCH
+ );
+
+ /* variables */
+ var zip_free_queue;
+ var zip_qhead, zip_qtail;
+ var zip_initflag;
+ var zip_outbuf = null;
+ var zip_outcnt, zip_outoff;
+ var zip_complete;
+ var zip_window;
+ var zip_d_buf;
+ var zip_l_buf;
+ var zip_prev;
+ var zip_bi_buf;
+ var zip_bi_valid;
+ var zip_block_start;
+ var zip_ins_h;
+ var zip_hash_head;
+ var zip_prev_match;
+ var zip_match_available;
+ var zip_match_length;
+ var zip_prev_length;
+ var zip_strstart;
+ var zip_match_start;
+ var zip_eofile;
+ var zip_lookahead;
+ var zip_max_chain_length;
+ var zip_max_lazy_match;
+ var zip_compr_level;
+ var zip_good_match;
+ var zip_nice_match;
+ var zip_dyn_ltree;
+ var zip_dyn_dtree;
+ var zip_static_ltree;
+ var zip_static_dtree;
+ var zip_bl_tree;
+ var zip_l_desc;
+ var zip_d_desc;
+ var zip_bl_desc;
+ var zip_bl_count;
+ var zip_heap;
+ var zip_heap_len;
+ var zip_heap_max;
+ var zip_depth;
+ var zip_length_code;
+ var zip_dist_code;
+ var zip_base_length;
+ var zip_base_dist;
+ var zip_flag_buf;
+ var zip_last_lit;
+ var zip_last_dist;
+ var zip_last_flags;
+ var zip_flags;
+ var zip_flag_bit;
+ var zip_opt_len;
+ var zip_static_len;
+ var zip_deflate_data;
+ var zip_deflate_pos;
+
+ /* objects (deflate) */
+
+ function zip_DeflateCT() {
this.fc = 0; // frequency count or bit string
this.dl = 0; // father node in Huffman tree or length of bit string
-}
-
-function zip_DeflateTreeDesc() {
- this.dyn_tree = null; // the dynamic tree
- this.static_tree = null; // corresponding static tree or NULL
- this.extra_bits = null; // extra bits for each code or NULL
- this.extra_base = 0; // base index for extra_bits
- this.elems = 0; // max number of elements in the tree
- this.max_length = 0; // max bit length for the codes
- this.max_code = 0; // largest code with non zero frequency
-}
-
-/* Values for max_lazy_match, good_match and max_chain_length, depending on
- * the desired pack level (0..9). The values given below have been tuned to
- * exclude worst case performance for pathological files. Better values may be
- * found for specific files.
- */
-function zip_DeflateConfiguration(a, b, c, d) {
+ }
+
+ function zip_DeflateTreeDesc() {
+ this.dyn_tree = null; // the dynamic tree
+ this.static_tree = null; // corresponding static tree or NULL
+ this.extra_bits = null; // extra bits for each code or NULL
+ this.extra_base = 0; // base index for extra_bits
+ this.elems = 0; // max number of elements in the tree
+ this.max_length = 0; // max bit length for the codes
+ this.max_code = 0; // largest code with non zero frequency
+ }
+
+ /* Values for max_lazy_match, good_match and max_chain_length, depending on
+ * the desired pack level (0..9). The values given below have been tuned to
+ * exclude worst case performance for pathological files. Better values may be
+ * found for specific files.
+ */
+ function zip_DeflateConfiguration(a, b, c, d) {
this.good_length = a; // reduce lazy search above this match length
- this.max_lazy = b; // do not perform lazy search above this match length
+ this.max_lazy = b; // do not perform lazy search above this match length
this.nice_length = c; // quit search above this match length
this.max_chain = d;
-}
+ }
-function zip_DeflateBuffer() {
+ function zip_DeflateBuffer() {
this.next = null;
this.len = 0;
this.ptr = new Array(zip_OUTBUFSIZ);
this.off = 0;
-}
-
-/* constant tables */
-var zip_extra_lbits = [
- 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];
-var zip_extra_dbits = [
- 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13];
-var zip_extra_blbits = [
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7];
-var zip_bl_order = [16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15];
-var zip_configuration_table = [
- new zip_DeflateConfiguration(0, 0, 0, 0),
- new zip_DeflateConfiguration(4, 4, 8, 4),
- new zip_DeflateConfiguration(4, 5, 16, 8),
- new zip_DeflateConfiguration(4, 6, 32, 32),
- new zip_DeflateConfiguration(4, 4, 16, 16),
- new zip_DeflateConfiguration(8, 16, 32, 32),
- new zip_DeflateConfiguration(8, 16, 128, 128),
- new zip_DeflateConfiguration(8, 32, 128, 256),
- new zip_DeflateConfiguration(32, 128, 258, 1024),
- new zip_DeflateConfiguration(32, 258, 258, 4096)];
-
-
-/* routines (deflate) */
-
-function zip_deflate_start(level) {
+ }
+
+ /* constant tables */
+ var zip_extra_lbits = [
+ 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,
+ ];
+ var zip_extra_dbits = [
+ 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10,
+ 11, 11, 12, 12, 13, 13,
+ ];
+ var zip_extra_blbits = [
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7,
+ ];
+ var zip_bl_order = [
+ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15,
+ ];
+ var zip_configuration_table = [
+ new zip_DeflateConfiguration(0, 0, 0, 0),
+ new zip_DeflateConfiguration(4, 4, 8, 4),
+ new zip_DeflateConfiguration(4, 5, 16, 8),
+ new zip_DeflateConfiguration(4, 6, 32, 32),
+ new zip_DeflateConfiguration(4, 4, 16, 16),
+ new zip_DeflateConfiguration(8, 16, 32, 32),
+ new zip_DeflateConfiguration(8, 16, 128, 128),
+ new zip_DeflateConfiguration(8, 32, 128, 256),
+ new zip_DeflateConfiguration(32, 128, 258, 1024),
+ new zip_DeflateConfiguration(32, 258, 258, 4096),
+ ];
+
+ /* routines (deflate) */
+
+ function zip_deflate_start(level) {
var i;
- if(!level)
- level = zip_DEFAULT_LEVEL;
- else if(level < 1)
- level = 1;
- else if(level > 9)
- level = 9;
+ if (!level) level = zip_DEFAULT_LEVEL;
+ else if (level < 1) level = 1;
+ else if (level > 9) level = 9;
zip_compr_level = level;
zip_initflag = false;
zip_eofile = false;
- if(zip_outbuf != null)
- return;
+ if (zip_outbuf != null) return;
zip_free_queue = zip_qhead = zip_qtail = null;
zip_outbuf = new Array(zip_OUTBUFSIZ);
@@ -211,34 +214,32 @@ function zip_deflate_start(level) {
zip_l_buf = new Array(zip_INBUFSIZ + zip_INBUF_EXTRA);
zip_prev = new Array(1 << zip_BITS);
zip_dyn_ltree = new Array(zip_HEAP_SIZE);
- for(i = 0; i < zip_HEAP_SIZE; i++)
- zip_dyn_ltree[i] = new zip_DeflateCT();
- zip_dyn_dtree = new Array(2*zip_D_CODES+1);
- for(i = 0; i < 2*zip_D_CODES+1; i++)
- zip_dyn_dtree[i] = new zip_DeflateCT();
- zip_static_ltree = new Array(zip_L_CODES+2);
- for(i = 0; i < zip_L_CODES+2; i++)
- zip_static_ltree[i] = new zip_DeflateCT();
+ for (i = 0; i < zip_HEAP_SIZE; i++) zip_dyn_ltree[i] = new zip_DeflateCT();
+ zip_dyn_dtree = new Array(2 * zip_D_CODES + 1);
+ for (i = 0; i < 2 * zip_D_CODES + 1; i++)
+ zip_dyn_dtree[i] = new zip_DeflateCT();
+ zip_static_ltree = new Array(zip_L_CODES + 2);
+ for (i = 0; i < zip_L_CODES + 2; i++)
+ zip_static_ltree[i] = new zip_DeflateCT();
zip_static_dtree = new Array(zip_D_CODES);
- for(i = 0; i < zip_D_CODES; i++)
- zip_static_dtree[i] = new zip_DeflateCT();
- zip_bl_tree = new Array(2*zip_BL_CODES+1);
- for(i = 0; i < 2*zip_BL_CODES+1; i++)
- zip_bl_tree[i] = new zip_DeflateCT();
+ for (i = 0; i < zip_D_CODES; i++) zip_static_dtree[i] = new zip_DeflateCT();
+ zip_bl_tree = new Array(2 * zip_BL_CODES + 1);
+ for (i = 0; i < 2 * zip_BL_CODES + 1; i++)
+ zip_bl_tree[i] = new zip_DeflateCT();
zip_l_desc = new zip_DeflateTreeDesc();
zip_d_desc = new zip_DeflateTreeDesc();
zip_bl_desc = new zip_DeflateTreeDesc();
- zip_bl_count = new Array(zip_MAX_BITS+1);
- zip_heap = new Array(2*zip_L_CODES+1);
- zip_depth = new Array(2*zip_L_CODES+1);
- zip_length_code = new Array(zip_MAX_MATCH-zip_MIN_MATCH+1);
+ zip_bl_count = new Array(zip_MAX_BITS + 1);
+ zip_heap = new Array(2 * zip_L_CODES + 1);
+ zip_depth = new Array(2 * zip_L_CODES + 1);
+ zip_length_code = new Array(zip_MAX_MATCH - zip_MIN_MATCH + 1);
zip_dist_code = new Array(512);
zip_base_length = new Array(zip_LENGTH_CODES);
zip_base_dist = new Array(zip_D_CODES);
zip_flag_buf = new Array(parseInt(zip_LIT_BUFSIZE / 8));
-}
+ }
-function zip_deflate_end() {
+ function zip_deflate_end() {
zip_free_queue = zip_qhead = zip_qtail = null;
zip_outbuf = null;
zip_window = null;
@@ -261,254 +262,259 @@ function zip_deflate_end() {
zip_base_length = null;
zip_base_dist = null;
zip_flag_buf = null;
-}
+ }
-function zip_reuse_queue(p) {
+ function zip_reuse_queue(p) {
p.next = zip_free_queue;
zip_free_queue = p;
-}
+ }
-function zip_new_queue() {
+ function zip_new_queue() {
var p;
- if(zip_free_queue != null)
- {
- p = zip_free_queue;
- zip_free_queue = zip_free_queue.next;
- }
- else
- p = new zip_DeflateBuffer();
+ if (zip_free_queue != null) {
+ p = zip_free_queue;
+ zip_free_queue = zip_free_queue.next;
+ } else p = new zip_DeflateBuffer();
p.next = null;
p.len = p.off = 0;
return p;
-}
+ }
-function zip_head1(i) {
+ function zip_head1(i) {
return zip_prev[zip_WSIZE + i];
-}
+ }
-function zip_head2(i, val) {
- return zip_prev[zip_WSIZE + i] = val;
-}
+ function zip_head2(i, val) {
+ return (zip_prev[zip_WSIZE + i] = val);
+ }
-/* put_byte is used for the compressed output, put_ubyte for the
- * uncompressed output. However unlzw() uses window for its
- * suffix table instead of its output buffer, so it does not use put_ubyte
- * (to be cleaned up).
- */
-function zip_put_byte(c) {
+ /* put_byte is used for the compressed output, put_ubyte for the
+ * uncompressed output. However unlzw() uses window for its
+ * suffix table instead of its output buffer, so it does not use put_ubyte
+ * (to be cleaned up).
+ */
+ function zip_put_byte(c) {
zip_outbuf[zip_outoff + zip_outcnt++] = c;
- if(zip_outoff + zip_outcnt == zip_OUTBUFSIZ)
- zip_qoutbuf();
-}
+ if (zip_outoff + zip_outcnt == zip_OUTBUFSIZ) zip_qoutbuf();
+ }
-/* Output a 16 bit value, lsb first */
-function zip_put_short(w) {
+ /* Output a 16 bit value, lsb first */
+ function zip_put_short(w) {
w &= 0xffff;
- if(zip_outoff + zip_outcnt < zip_OUTBUFSIZ - 2) {
- zip_outbuf[zip_outoff + zip_outcnt++] = (w & 0xff);
- zip_outbuf[zip_outoff + zip_outcnt++] = (w >>> 8);
+ if (zip_outoff + zip_outcnt < zip_OUTBUFSIZ - 2) {
+ zip_outbuf[zip_outoff + zip_outcnt++] = w & 0xff;
+ zip_outbuf[zip_outoff + zip_outcnt++] = w >>> 8;
} else {
- zip_put_byte(w & 0xff);
- zip_put_byte(w >>> 8);
+ zip_put_byte(w & 0xff);
+ zip_put_byte(w >>> 8);
}
-}
-
-/* ==========================================================================
- * Insert string s in the dictionary and set match_head to the previous head
- * of the hash chain (the most recent string with same hash key). Return
- * the previous length of the hash chain.
- * IN assertion: all calls to to INSERT_STRING are made with consecutive
- * input characters and the first MIN_MATCH bytes of s are valid
- * (except for the last MIN_MATCH-1 bytes of the input file).
- */
-function zip_INSERT_STRING() {
- zip_ins_h = ((zip_ins_h << zip_H_SHIFT)
- ^ (zip_window[zip_strstart + zip_MIN_MATCH - 1] & 0xff))
- & zip_HASH_MASK;
+ }
+
+ /* ==========================================================================
+ * Insert string s in the dictionary and set match_head to the previous head
+ * of the hash chain (the most recent string with same hash key). Return
+ * the previous length of the hash chain.
+ * IN assertion: all calls to to INSERT_STRING are made with consecutive
+ * input characters and the first MIN_MATCH bytes of s are valid
+ * (except for the last MIN_MATCH-1 bytes of the input file).
+ */
+ function zip_INSERT_STRING() {
+ zip_ins_h =
+ ((zip_ins_h << zip_H_SHIFT) ^
+ (zip_window[zip_strstart + zip_MIN_MATCH - 1] & 0xff)) &
+ zip_HASH_MASK;
zip_hash_head = zip_head1(zip_ins_h);
zip_prev[zip_strstart & zip_WMASK] = zip_hash_head;
zip_head2(zip_ins_h, zip_strstart);
-}
+ }
-/* Send a code of the given tree. c and tree must not have side effects */
-function zip_SEND_CODE(c, tree) {
+ /* Send a code of the given tree. c and tree must not have side effects */
+ function zip_SEND_CODE(c, tree) {
zip_send_bits(tree[c].fc, tree[c].dl);
-}
+ }
-/* Mapping from a distance to a distance code. dist is the distance - 1 and
- * must not have side effects. dist_code[256] and dist_code[257] are never
- * used.
- */
-function zip_D_CODE(dist) {
- return (dist < 256 ? zip_dist_code[dist]
- : zip_dist_code[256 + (dist>>7)]) & 0xff;
-}
-
-/* ==========================================================================
- * Compares to subtrees, using the tree depth as tie breaker when
- * the subtrees have equal frequency. This minimizes the worst case length.
- */
-function zip_SMALLER(tree, n, m) {
- return tree[n].fc < tree[m].fc ||
- (tree[n].fc == tree[m].fc && zip_depth[n] <= zip_depth[m]);
-}
+ /* Mapping from a distance to a distance code. dist is the distance - 1 and
+ * must not have side effects. dist_code[256] and dist_code[257] are never
+ * used.
+ */
+ function zip_D_CODE(dist) {
+ return (
+ (dist < 256 ? zip_dist_code[dist] : zip_dist_code[256 + (dist >> 7)]) &
+ 0xff
+ );
+ }
-/* ==========================================================================
- * read string data
- */
-function zip_read_buff(buff, offset, n) {
+ /* ==========================================================================
+ * Compares to subtrees, using the tree depth as tie breaker when
+ * the subtrees have equal frequency. This minimizes the worst case length.
+ */
+ function zip_SMALLER(tree, n, m) {
+ return (
+ tree[n].fc < tree[m].fc ||
+ (tree[n].fc == tree[m].fc && zip_depth[n] <= zip_depth[m])
+ );
+ }
+
+ /* ==========================================================================
+ * read string data
+ */
+ function zip_read_buff(buff, offset, n) {
var i;
- for(i = 0; i < n && zip_deflate_pos < zip_deflate_data.length; i++)
- buff[offset + i] =
- zip_deflate_data.charCodeAt(zip_deflate_pos++) & 0xff;
+ for (i = 0; i < n && zip_deflate_pos < zip_deflate_data.length; i++)
+ buff[offset + i] = zip_deflate_data.charCodeAt(zip_deflate_pos++) & 0xff;
return i;
-}
+ }
-/* ==========================================================================
- * Initialize the "longest match" routines for a new file
- */
-function zip_lm_init() {
+ /* ==========================================================================
+ * Initialize the "longest match" routines for a new file
+ */
+ function zip_lm_init() {
var j;
/* Initialize the hash table. */
- for(j = 0; j < zip_HASH_SIZE; j++)
-// zip_head2(j, zip_NIL);
- zip_prev[zip_WSIZE + j] = 0;
+ for (j = 0; j < zip_HASH_SIZE; j++)
+ // zip_head2(j, zip_NIL);
+ zip_prev[zip_WSIZE + j] = 0;
/* prev will be initialized on the fly */
/* Set the default configuration parameters:
*/
zip_max_lazy_match = zip_configuration_table[zip_compr_level].max_lazy;
- zip_good_match = zip_configuration_table[zip_compr_level].good_length;
- if(!zip_FULL_SEARCH)
- zip_nice_match = zip_configuration_table[zip_compr_level].nice_length;
+ zip_good_match = zip_configuration_table[zip_compr_level].good_length;
+ if (!zip_FULL_SEARCH)
+ zip_nice_match = zip_configuration_table[zip_compr_level].nice_length;
zip_max_chain_length = zip_configuration_table[zip_compr_level].max_chain;
zip_strstart = 0;
zip_block_start = 0;
zip_lookahead = zip_read_buff(zip_window, 0, 2 * zip_WSIZE);
- if(zip_lookahead <= 0) {
- zip_eofile = true;
- zip_lookahead = 0;
- return;
+ if (zip_lookahead <= 0) {
+ zip_eofile = true;
+ zip_lookahead = 0;
+ return;
}
zip_eofile = false;
/* Make sure that we always have enough lookahead. This is important
* if input comes from a device such as a tty.
*/
- while(zip_lookahead < zip_MIN_LOOKAHEAD && !zip_eofile)
- zip_fill_window();
+ while (zip_lookahead < zip_MIN_LOOKAHEAD && !zip_eofile) zip_fill_window();
/* If lookahead < MIN_MATCH, ins_h is garbage, but this is
* not important since only literal bytes will be emitted.
*/
zip_ins_h = 0;
- for(j = 0; j < zip_MIN_MATCH - 1; j++) {
-// UPDATE_HASH(ins_h, window[j]);
- zip_ins_h = ((zip_ins_h << zip_H_SHIFT) ^ (zip_window[j] & 0xff)) & zip_HASH_MASK;
+ for (j = 0; j < zip_MIN_MATCH - 1; j++) {
+ // UPDATE_HASH(ins_h, window[j]);
+ zip_ins_h =
+ ((zip_ins_h << zip_H_SHIFT) ^ (zip_window[j] & 0xff)) & zip_HASH_MASK;
}
-}
-
-/* ==========================================================================
- * Set match_start to the longest match starting at the given string and
- * return its length. Matches shorter or equal to prev_length are discarded,
- * in which case the result is equal to prev_length and match_start is
- * garbage.
- * IN assertions: cur_match is the head of the hash chain for the current
- * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
- */
-function zip_longest_match(cur_match) {
+ }
+
+ /* ==========================================================================
+ * Set match_start to the longest match starting at the given string and
+ * return its length. Matches shorter or equal to prev_length are discarded,
+ * in which case the result is equal to prev_length and match_start is
+ * garbage.
+ * IN assertions: cur_match is the head of the hash chain for the current
+ * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
+ */
+ function zip_longest_match(cur_match) {
var chain_length = zip_max_chain_length; // max hash chain length
var scanp = zip_strstart; // current string
- var matchp; // matched string
- var len; // length of current match
- var best_len = zip_prev_length; // best match length so far
+ var matchp; // matched string
+ var len; // length of current match
+ var best_len = zip_prev_length; // best match length so far
/* Stop when cur_match becomes <= limit. To simplify the code,
* we prevent matches with the string of window index 0.
*/
- var limit = (zip_strstart > zip_MAX_DIST ? zip_strstart - zip_MAX_DIST : zip_NIL);
+ var limit =
+ zip_strstart > zip_MAX_DIST ? zip_strstart - zip_MAX_DIST : zip_NIL;
var strendp = zip_strstart + zip_MAX_MATCH;
var scan_end1 = zip_window[scanp + best_len - 1];
- var scan_end = zip_window[scanp + best_len];
+ var scan_end = zip_window[scanp + best_len];
/* Do not waste too much time if we already have a good match: */
- if(zip_prev_length >= zip_good_match)
- chain_length >>= 2;
+ if (zip_prev_length >= zip_good_match) chain_length >>= 2;
-// Assert(encoder->strstart <= window_size-MIN_LOOKAHEAD, "insufficient lookahead");
+ // Assert(encoder->strstart <= window_size-MIN_LOOKAHEAD, "insufficient lookahead");
do {
-// Assert(cur_match < encoder->strstart, "no future");
- matchp = cur_match;
-
- /* Skip to next match if the match length cannot increase
- * or if the match length is less than 2:
- */
- if(zip_window[matchp + best_len] != scan_end ||
- zip_window[matchp + best_len - 1] != scan_end1 ||
- zip_window[matchp] != zip_window[scanp] ||
- zip_window[++matchp] != zip_window[scanp + 1]) {
- continue;
- }
-
- /* The check at best_len-1 can be removed because it will be made
- * again later. (This heuristic is not always a win.)
- * It is not necessary to compare scan[2] and match[2] since they
- * are always equal when the other bytes match, given that
- * the hash keys are equal and that HASH_BITS >= 8.
- */
- scanp += 2;
- matchp++;
+ // Assert(cur_match < encoder->strstart, "no future");
+ matchp = cur_match;
+
+ /* Skip to next match if the match length cannot increase
+ * or if the match length is less than 2:
+ */
+ if (
+ zip_window[matchp + best_len] != scan_end ||
+ zip_window[matchp + best_len - 1] != scan_end1 ||
+ zip_window[matchp] != zip_window[scanp] ||
+ zip_window[++matchp] != zip_window[scanp + 1]
+ ) {
+ continue;
+ }
- /* We check for insufficient lookahead only every 8th comparison;
- * the 256th check will be made at strstart+258.
- */
- do {
- } while(zip_window[++scanp] == zip_window[++matchp] &&
- zip_window[++scanp] == zip_window[++matchp] &&
- zip_window[++scanp] == zip_window[++matchp] &&
- zip_window[++scanp] == zip_window[++matchp] &&
- zip_window[++scanp] == zip_window[++matchp] &&
- zip_window[++scanp] == zip_window[++matchp] &&
- zip_window[++scanp] == zip_window[++matchp] &&
- zip_window[++scanp] == zip_window[++matchp] &&
- scanp < strendp);
+ /* The check at best_len-1 can be removed because it will be made
+ * again later. (This heuristic is not always a win.)
+ * It is not necessary to compare scan[2] and match[2] since they
+ * are always equal when the other bytes match, given that
+ * the hash keys are equal and that HASH_BITS >= 8.
+ */
+ scanp += 2;
+ matchp++;
+
+ /* We check for insufficient lookahead only every 8th comparison;
+ * the 256th check will be made at strstart+258.
+ */
+ do {} while (
+ zip_window[++scanp] == zip_window[++matchp] &&
+ zip_window[++scanp] == zip_window[++matchp] &&
+ zip_window[++scanp] == zip_window[++matchp] &&
+ zip_window[++scanp] == zip_window[++matchp] &&
+ zip_window[++scanp] == zip_window[++matchp] &&
+ zip_window[++scanp] == zip_window[++matchp] &&
+ zip_window[++scanp] == zip_window[++matchp] &&
+ zip_window[++scanp] == zip_window[++matchp] &&
+ scanp < strendp
+ );
len = zip_MAX_MATCH - (strendp - scanp);
scanp = strendp - zip_MAX_MATCH;
- if(len > best_len) {
- zip_match_start = cur_match;
- best_len = len;
- if(zip_FULL_SEARCH) {
- if(len >= zip_MAX_MATCH) break;
- } else {
- if(len >= zip_nice_match) break;
- }
-
- scan_end1 = zip_window[scanp + best_len-1];
- scan_end = zip_window[scanp + best_len];
+ if (len > best_len) {
+ zip_match_start = cur_match;
+ best_len = len;
+ if (zip_FULL_SEARCH) {
+ if (len >= zip_MAX_MATCH) break;
+ } else {
+ if (len >= zip_nice_match) break;
+ }
+
+ scan_end1 = zip_window[scanp + best_len - 1];
+ scan_end = zip_window[scanp + best_len];
}
- } while((cur_match = zip_prev[cur_match & zip_WMASK]) > limit
- && --chain_length != 0);
+ } while (
+ (cur_match = zip_prev[cur_match & zip_WMASK]) > limit &&
+ --chain_length != 0
+ );
return best_len;
-}
-
-/* ==========================================================================
- * Fill the window when the lookahead becomes insufficient.
- * Updates strstart and lookahead, and sets eofile if end of input file.
- * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0
- * OUT assertions: at least one byte has been read, or eofile is set;
- * file reads are performed for at least two bytes (required for the
- * translate_eol option).
- */
-function zip_fill_window() {
+ }
+
+ /* ==========================================================================
+ * Fill the window when the lookahead becomes insufficient.
+ * Updates strstart and lookahead, and sets eofile if end of input file.
+ * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0
+ * OUT assertions: at least one byte has been read, or eofile is set;
+ * file reads are performed for at least two bytes (required for the
+ * translate_eol option).
+ */
+ function zip_fill_window() {
var n, m;
// Amount of free space at the end of the window.
@@ -517,232 +523,240 @@ function zip_fill_window() {
/* If the window is almost full and there is insufficient lookahead,
* move the upper half to the lower one to make room in the upper half.
*/
- if(more == -1) {
- /* Very unlikely, but possible on 16 bit machine if strstart == 0
- * and lookahead == 1 (input done one byte at time)
- */
- more--;
- } else if(zip_strstart >= zip_WSIZE + zip_MAX_DIST) {
- /* By the IN assertion, the window is not empty so we can't confuse
- * more == 0 with more == 64K on a 16 bit machine.
+ if (more == -1) {
+ /* Very unlikely, but possible on 16 bit machine if strstart == 0
+ * and lookahead == 1 (input done one byte at time)
+ */
+ more--;
+ } else if (zip_strstart >= zip_WSIZE + zip_MAX_DIST) {
+ /* By the IN assertion, the window is not empty so we can't confuse
+ * more == 0 with more == 64K on a 16 bit machine.
+ */
+ // Assert(window_size == (ulg)2*WSIZE, "no sliding with BIG_MEM");
+
+ // System.arraycopy(window, WSIZE, window, 0, WSIZE);
+ for (n = 0; n < zip_WSIZE; n++) zip_window[n] = zip_window[n + zip_WSIZE];
+
+ zip_match_start -= zip_WSIZE;
+ zip_strstart -= zip_WSIZE; /* we now have strstart >= MAX_DIST: */
+ zip_block_start -= zip_WSIZE;
+
+ for (n = 0; n < zip_HASH_SIZE; n++) {
+ m = zip_head1(n);
+ zip_head2(n, m >= zip_WSIZE ? m - zip_WSIZE : zip_NIL);
+ }
+ for (n = 0; n < zip_WSIZE; n++) {
+ /* If n is not on any hash chain, prev[n] is garbage but
+ * its value will never be used.
*/
-// Assert(window_size == (ulg)2*WSIZE, "no sliding with BIG_MEM");
-
-// System.arraycopy(window, WSIZE, window, 0, WSIZE);
- for(n = 0; n < zip_WSIZE; n++)
- zip_window[n] = zip_window[n + zip_WSIZE];
-
- zip_match_start -= zip_WSIZE;
- zip_strstart -= zip_WSIZE; /* we now have strstart >= MAX_DIST: */
- zip_block_start -= zip_WSIZE;
-
- for(n = 0; n < zip_HASH_SIZE; n++) {
- m = zip_head1(n);
- zip_head2(n, m >= zip_WSIZE ? m - zip_WSIZE : zip_NIL);
- }
- for(n = 0; n < zip_WSIZE; n++) {
- /* If n is not on any hash chain, prev[n] is garbage but
- * its value will never be used.
- */
- m = zip_prev[n];
- zip_prev[n] = (m >= zip_WSIZE ? m - zip_WSIZE : zip_NIL);
- }
- more += zip_WSIZE;
+ m = zip_prev[n];
+ zip_prev[n] = m >= zip_WSIZE ? m - zip_WSIZE : zip_NIL;
+ }
+ more += zip_WSIZE;
}
// At this point, more >= 2
- if(!zip_eofile) {
- n = zip_read_buff(zip_window, zip_strstart + zip_lookahead, more);
- if(n <= 0)
- zip_eofile = true;
- else
- zip_lookahead += n;
+ if (!zip_eofile) {
+ n = zip_read_buff(zip_window, zip_strstart + zip_lookahead, more);
+ if (n <= 0) zip_eofile = true;
+ else zip_lookahead += n;
}
-}
+ }
-/* ==========================================================================
- * Processes a new input file and return its compressed length. This
- * function does not perform lazy evaluationof matches and inserts
- * new strings in the dictionary only for unmatched strings or for short
- * matches. It is used only for the fast compression options.
- */
-function zip_deflate_fast() {
- while(zip_lookahead != 0 && zip_qhead == null) {
- var flush; // set if current block must be flushed
-
- /* Insert the string window[strstart .. strstart+2] in the
- * dictionary, and set hash_head to the head of the hash chain:
- */
- zip_INSERT_STRING();
-
- /* Find the longest match, discarding those <= prev_length.
- * At this point we have always match_length < MIN_MATCH
- */
- if(zip_hash_head != zip_NIL &&
- zip_strstart - zip_hash_head <= zip_MAX_DIST) {
- /* 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).
- */
- zip_match_length = zip_longest_match(zip_hash_head);
- /* longest_match() sets match_start */
- if(zip_match_length > zip_lookahead)
- zip_match_length = zip_lookahead;
- }
- if(zip_match_length >= zip_MIN_MATCH) {
-// check_match(strstart, match_start, match_length);
-
- flush = zip_ct_tally(zip_strstart - zip_match_start,
- zip_match_length - zip_MIN_MATCH);
- zip_lookahead -= zip_match_length;
-
- /* Insert new strings in the hash table only if the match length
- * is not too large. This saves time but degrades compression.
- */
- if(zip_match_length <= zip_max_lazy_match) {
- zip_match_length--; // string at strstart already in hash table
- do {
- zip_strstart++;
- zip_INSERT_STRING();
- /* strstart never exceeds WSIZE-MAX_MATCH, so there are
- * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
- * these bytes are garbage, but it does not matter since
- * the next lookahead bytes will be emitted as literals.
- */
- } while(--zip_match_length != 0);
- zip_strstart++;
- } else {
- zip_strstart += zip_match_length;
- zip_match_length = 0;
- zip_ins_h = zip_window[zip_strstart] & 0xff;
-// UPDATE_HASH(ins_h, window[strstart + 1]);
- zip_ins_h = ((zip_ins_h< zip_lookahead) zip_match_length = zip_lookahead;
+ }
+ if (zip_match_length >= zip_MIN_MATCH) {
+ // check_match(strstart, match_start, match_length);
+
+ flush = zip_ct_tally(
+ zip_strstart - zip_match_start,
+ zip_match_length - zip_MIN_MATCH
+ );
+ zip_lookahead -= zip_match_length;
+
+ /* Insert new strings in the hash table only if the match length
+ * is not too large. This saves time but degrades compression.
+ */
+ if (zip_match_length <= zip_max_lazy_match) {
+ zip_match_length--; // string at strstart already in hash table
+ do {
+ zip_strstart++;
+ zip_INSERT_STRING();
+ /* strstart never exceeds WSIZE-MAX_MATCH, so there are
+ * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
+ * these bytes are garbage, but it does not matter since
+ * the next lookahead bytes will be emitted as literals.
+ */
+ } while (--zip_match_length != 0);
+ zip_strstart++;
+ } else {
+ zip_strstart += zip_match_length;
+ zip_match_length = 0;
+ zip_ins_h = zip_window[zip_strstart] & 0xff;
+ // UPDATE_HASH(ins_h, window[strstart + 1]);
+ zip_ins_h =
+ ((zip_ins_h << zip_H_SHIFT) ^
+ (zip_window[zip_strstart + 1] & 0xff)) &
+ zip_HASH_MASK;
+
+ //#if MIN_MATCH != 3
+ // Call UPDATE_HASH() MIN_MATCH-3 more times
+ //#endif
+ }
+ } else {
+ /* No match, output a literal byte */
+ flush = zip_ct_tally(0, zip_window[zip_strstart] & 0xff);
+ zip_lookahead--;
+ zip_strstart++;
+ }
+ if (flush) {
+ zip_flush_block(0);
+ zip_block_start = zip_strstart;
+ }
+
+ /* Make sure that we always have enough lookahead, except
+ * at the end of the input file. We need MAX_MATCH bytes
+ * for the next match, plus MIN_MATCH bytes to insert the
+ * string following the next match.
+ */
+ while (zip_lookahead < zip_MIN_LOOKAHEAD && !zip_eofile)
+ zip_fill_window();
}
-}
+ }
-function zip_deflate_better() {
+ function zip_deflate_better() {
/* Process the input block. */
- while(zip_lookahead != 0 && zip_qhead == null) {
- /* Insert the string window[strstart .. strstart+2] in the
- * dictionary, and set hash_head to the head of the hash chain:
- */
- zip_INSERT_STRING();
-
- /* Find the longest match, discarding those <= prev_length.
- */
- zip_prev_length = zip_match_length;
- zip_prev_match = zip_match_start;
- zip_match_length = zip_MIN_MATCH - 1;
-
- if(zip_hash_head != zip_NIL &&
- zip_prev_length < zip_max_lazy_match &&
- zip_strstart - zip_hash_head <= zip_MAX_DIST) {
- /* 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).
- */
- zip_match_length = zip_longest_match(zip_hash_head);
- /* longest_match() sets match_start */
- if(zip_match_length > zip_lookahead)
- zip_match_length = zip_lookahead;
-
- /* Ignore a length 3 match if it is too distant: */
- if(zip_match_length == zip_MIN_MATCH &&
- zip_strstart - zip_match_start > zip_TOO_FAR) {
- /* If prev_match is also MIN_MATCH, match_start is garbage
- * but we will ignore the current match anyway.
- */
- zip_match_length--;
- }
- }
- /* If there was a match at the previous step and the current
- * match is not better, output the previous match:
- */
- if(zip_prev_length >= zip_MIN_MATCH &&
- zip_match_length <= zip_prev_length) {
- var flush; // set if current block must be flushed
-
-// check_match(strstart - 1, prev_match, prev_length);
- flush = zip_ct_tally(zip_strstart - 1 - zip_prev_match,
- zip_prev_length - zip_MIN_MATCH);
-
- /* Insert in hash table all strings up to the end of the match.
- * strstart-1 and strstart are already inserted.
- */
- zip_lookahead -= zip_prev_length - 1;
- zip_prev_length -= 2;
- do {
- zip_strstart++;
- zip_INSERT_STRING();
- /* strstart never exceeds WSIZE-MAX_MATCH, so there are
- * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
- * these bytes are garbage, but it does not matter since the
- * next lookahead bytes will always be emitted as literals.
- */
- } while(--zip_prev_length != 0);
- zip_match_available = 0;
- zip_match_length = zip_MIN_MATCH - 1;
- zip_strstart++;
- if(flush) {
- zip_flush_block(0);
- zip_block_start = zip_strstart;
- }
- } else if(zip_match_available != 0) {
- /* If there was no match at the previous position, output a
- * single literal. If there was a match but the current match
- * is longer, truncate the previous match to a single literal.
- */
- if(zip_ct_tally(0, zip_window[zip_strstart - 1] & 0xff)) {
- zip_flush_block(0);
- zip_block_start = zip_strstart;
- }
- zip_strstart++;
- zip_lookahead--;
- } else {
- /* There is no previous match to compare with, wait for
- * the next step to decide.
- */
- zip_match_available = 1;
- zip_strstart++;
- zip_lookahead--;
- }
-
- /* Make sure that we always have enough lookahead, except
- * at the end of the input file. We need MAX_MATCH bytes
- * for the next match, plus MIN_MATCH bytes to insert the
- * string following the next match.
- */
- while(zip_lookahead < zip_MIN_LOOKAHEAD && !zip_eofile)
- zip_fill_window();
+ while (zip_lookahead != 0 && zip_qhead == null) {
+ /* Insert the string window[strstart .. strstart+2] in the
+ * dictionary, and set hash_head to the head of the hash chain:
+ */
+ zip_INSERT_STRING();
+
+ /* Find the longest match, discarding those <= prev_length.
+ */
+ zip_prev_length = zip_match_length;
+ zip_prev_match = zip_match_start;
+ zip_match_length = zip_MIN_MATCH - 1;
+
+ if (
+ zip_hash_head != zip_NIL &&
+ zip_prev_length < zip_max_lazy_match &&
+ zip_strstart - zip_hash_head <= zip_MAX_DIST
+ ) {
+ /* 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).
+ */
+ zip_match_length = zip_longest_match(zip_hash_head);
+ /* longest_match() sets match_start */
+ if (zip_match_length > zip_lookahead) zip_match_length = zip_lookahead;
+
+ /* Ignore a length 3 match if it is too distant: */
+ if (
+ zip_match_length == zip_MIN_MATCH &&
+ zip_strstart - zip_match_start > zip_TOO_FAR
+ ) {
+ /* If prev_match is also MIN_MATCH, match_start is garbage
+ * but we will ignore the current match anyway.
+ */
+ zip_match_length--;
+ }
+ }
+ /* If there was a match at the previous step and the current
+ * match is not better, output the previous match:
+ */
+ if (
+ zip_prev_length >= zip_MIN_MATCH &&
+ zip_match_length <= zip_prev_length
+ ) {
+ var flush; // set if current block must be flushed
+
+ // check_match(strstart - 1, prev_match, prev_length);
+ flush = zip_ct_tally(
+ zip_strstart - 1 - zip_prev_match,
+ zip_prev_length - zip_MIN_MATCH
+ );
+
+ /* Insert in hash table all strings up to the end of the match.
+ * strstart-1 and strstart are already inserted.
+ */
+ zip_lookahead -= zip_prev_length - 1;
+ zip_prev_length -= 2;
+ do {
+ zip_strstart++;
+ zip_INSERT_STRING();
+ /* strstart never exceeds WSIZE-MAX_MATCH, so there are
+ * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
+ * these bytes are garbage, but it does not matter since the
+ * next lookahead bytes will always be emitted as literals.
+ */
+ } while (--zip_prev_length != 0);
+ zip_match_available = 0;
+ zip_match_length = zip_MIN_MATCH - 1;
+ zip_strstart++;
+ if (flush) {
+ zip_flush_block(0);
+ zip_block_start = zip_strstart;
+ }
+ } else if (zip_match_available != 0) {
+ /* If there was no match at the previous position, output a
+ * single literal. If there was a match but the current match
+ * is longer, truncate the previous match to a single literal.
+ */
+ if (zip_ct_tally(0, zip_window[zip_strstart - 1] & 0xff)) {
+ zip_flush_block(0);
+ zip_block_start = zip_strstart;
+ }
+ zip_strstart++;
+ zip_lookahead--;
+ } else {
+ /* There is no previous match to compare with, wait for
+ * the next step to decide.
+ */
+ zip_match_available = 1;
+ zip_strstart++;
+ zip_lookahead--;
+ }
+
+ /* Make sure that we always have enough lookahead, except
+ * at the end of the input file. We need MAX_MATCH bytes
+ * for the next match, plus MIN_MATCH bytes to insert the
+ * string following the next match.
+ */
+ while (zip_lookahead < zip_MIN_LOOKAHEAD && !zip_eofile)
+ zip_fill_window();
}
-}
+ }
-function zip_init_deflate() {
- if(zip_eofile)
- return;
+ function zip_init_deflate() {
+ if (zip_eofile) return;
zip_bi_buf = 0;
zip_bi_valid = 0;
zip_ct_init();
@@ -752,143 +766,132 @@ function zip_init_deflate() {
zip_outcnt = 0;
zip_outoff = 0;
- if(zip_compr_level <= 3)
- {
- zip_prev_length = zip_MIN_MATCH - 1;
- zip_match_length = 0;
- }
- else
- {
- zip_match_length = zip_MIN_MATCH - 1;
- zip_match_available = 0;
+ if (zip_compr_level <= 3) {
+ zip_prev_length = zip_MIN_MATCH - 1;
+ zip_match_length = 0;
+ } else {
+ zip_match_length = zip_MIN_MATCH - 1;
+ zip_match_available = 0;
}
zip_complete = false;
-}
+ }
-/* ==========================================================================
- * Same as above, but achieves better compression. We use a lazy
- * evaluation for matches: a match is finally adopted only if there is
- * no better match at the next window position.
- */
-function zip_deflate_internal(buff, off, buff_size) {
+ /* ==========================================================================
+ * Same as above, but achieves better compression. We use a lazy
+ * evaluation for matches: a match is finally adopted only if there is
+ * no better match at the next window position.
+ */
+ function zip_deflate_internal(buff, off, buff_size) {
var n;
- if(!zip_initflag)
- {
- zip_init_deflate();
- zip_initflag = true;
- if(zip_lookahead == 0) { // empty
- zip_complete = true;
- return 0;
- }
+ if (!zip_initflag) {
+ zip_init_deflate();
+ zip_initflag = true;
+ if (zip_lookahead == 0) {
+ // empty
+ zip_complete = true;
+ return 0;
+ }
}
- if((n = zip_qcopy(buff, off, buff_size)) == buff_size)
- return buff_size;
-
- if(zip_complete)
- return n;
-
- if(zip_compr_level <= 3) // optimized for speed
- zip_deflate_fast();
- else
- zip_deflate_better();
- if(zip_lookahead == 0) {
- if(zip_match_available != 0)
- zip_ct_tally(0, zip_window[zip_strstart - 1] & 0xff);
- zip_flush_block(1);
- zip_complete = true;
+ if ((n = zip_qcopy(buff, off, buff_size)) == buff_size) return buff_size;
+
+ if (zip_complete) return n;
+
+ if (zip_compr_level <= 3)
+ // optimized for speed
+ zip_deflate_fast();
+ else zip_deflate_better();
+ if (zip_lookahead == 0) {
+ if (zip_match_available != 0)
+ zip_ct_tally(0, zip_window[zip_strstart - 1] & 0xff);
+ zip_flush_block(1);
+ zip_complete = true;
}
return n + zip_qcopy(buff, n + off, buff_size - n);
-}
+ }
-function zip_qcopy(buff, off, buff_size) {
+ function zip_qcopy(buff, off, buff_size) {
var n, i, j;
n = 0;
- while(zip_qhead != null && n < buff_size)
- {
- i = buff_size - n;
- if(i > zip_qhead.len)
- i = zip_qhead.len;
-// System.arraycopy(qhead.ptr, qhead.off, buff, off + n, i);
- for(j = 0; j < i; j++)
- buff[off + n + j] = zip_qhead.ptr[zip_qhead.off + j];
-
- zip_qhead.off += i;
- zip_qhead.len -= i;
- n += i;
- if(zip_qhead.len == 0) {
- var p;
- p = zip_qhead;
- zip_qhead = zip_qhead.next;
- zip_reuse_queue(p);
- }
+ while (zip_qhead != null && n < buff_size) {
+ i = buff_size - n;
+ if (i > zip_qhead.len) i = zip_qhead.len;
+ // System.arraycopy(qhead.ptr, qhead.off, buff, off + n, i);
+ for (j = 0; j < i; j++)
+ buff[off + n + j] = zip_qhead.ptr[zip_qhead.off + j];
+
+ zip_qhead.off += i;
+ zip_qhead.len -= i;
+ n += i;
+ if (zip_qhead.len == 0) {
+ var p;
+ p = zip_qhead;
+ zip_qhead = zip_qhead.next;
+ zip_reuse_queue(p);
+ }
}
- if(n == buff_size)
- return n;
-
- if(zip_outoff < zip_outcnt) {
- i = buff_size - n;
- if(i > zip_outcnt - zip_outoff)
- i = zip_outcnt - zip_outoff;
- // System.arraycopy(outbuf, outoff, buff, off + n, i);
- for(j = 0; j < i; j++)
- buff[off + n + j] = zip_outbuf[zip_outoff + j];
- zip_outoff += i;
- n += i;
- if(zip_outcnt == zip_outoff)
- zip_outcnt = zip_outoff = 0;
+ if (n == buff_size) return n;
+
+ if (zip_outoff < zip_outcnt) {
+ i = buff_size - n;
+ if (i > zip_outcnt - zip_outoff) i = zip_outcnt - zip_outoff;
+ // System.arraycopy(outbuf, outoff, buff, off + n, i);
+ for (j = 0; j < i; j++) buff[off + n + j] = zip_outbuf[zip_outoff + j];
+ zip_outoff += i;
+ n += i;
+ if (zip_outcnt == zip_outoff) zip_outcnt = zip_outoff = 0;
}
return n;
-}
+ }
-/* ==========================================================================
- * Allocate the match buffer, initialize the various tables and save the
- * location of the internal file attribute (ascii/binary) and method
- * (DEFLATE/STORE).
- */
-function zip_ct_init() {
- var n; // iterates over tree elements
- var bits; // bit counter
- var length; // length value
- var code; // code value
- var dist; // distance index
-
- if(zip_static_dtree[0].dl != 0) return; // ct_init already called
-
- zip_l_desc.dyn_tree = zip_dyn_ltree;
- zip_l_desc.static_tree = zip_static_ltree;
- zip_l_desc.extra_bits = zip_extra_lbits;
- zip_l_desc.extra_base = zip_LITERALS + 1;
- zip_l_desc.elems = zip_L_CODES;
- zip_l_desc.max_length = zip_MAX_BITS;
- zip_l_desc.max_code = 0;
-
- zip_d_desc.dyn_tree = zip_dyn_dtree;
- zip_d_desc.static_tree = zip_static_dtree;
- zip_d_desc.extra_bits = zip_extra_dbits;
- zip_d_desc.extra_base = 0;
- zip_d_desc.elems = zip_D_CODES;
- zip_d_desc.max_length = zip_MAX_BITS;
- zip_d_desc.max_code = 0;
-
- zip_bl_desc.dyn_tree = zip_bl_tree;
- zip_bl_desc.static_tree = null;
- zip_bl_desc.extra_bits = zip_extra_blbits;
- zip_bl_desc.extra_base = 0;
- zip_bl_desc.elems = zip_BL_CODES;
- zip_bl_desc.max_length = zip_MAX_BL_BITS;
- zip_bl_desc.max_code = 0;
+ /* ==========================================================================
+ * Allocate the match buffer, initialize the various tables and save the
+ * location of the internal file attribute (ascii/binary) and method
+ * (DEFLATE/STORE).
+ */
+ function zip_ct_init() {
+ var n; // iterates over tree elements
+ var bits; // bit counter
+ var length; // length value
+ var code; // code value
+ var dist; // distance index
+
+ if (zip_static_dtree[0].dl != 0) return; // ct_init already called
+
+ zip_l_desc.dyn_tree = zip_dyn_ltree;
+ zip_l_desc.static_tree = zip_static_ltree;
+ zip_l_desc.extra_bits = zip_extra_lbits;
+ zip_l_desc.extra_base = zip_LITERALS + 1;
+ zip_l_desc.elems = zip_L_CODES;
+ zip_l_desc.max_length = zip_MAX_BITS;
+ zip_l_desc.max_code = 0;
+
+ zip_d_desc.dyn_tree = zip_dyn_dtree;
+ zip_d_desc.static_tree = zip_static_dtree;
+ zip_d_desc.extra_bits = zip_extra_dbits;
+ zip_d_desc.extra_base = 0;
+ zip_d_desc.elems = zip_D_CODES;
+ zip_d_desc.max_length = zip_MAX_BITS;
+ zip_d_desc.max_code = 0;
+
+ zip_bl_desc.dyn_tree = zip_bl_tree;
+ zip_bl_desc.static_tree = null;
+ zip_bl_desc.extra_bits = zip_extra_blbits;
+ zip_bl_desc.extra_base = 0;
+ zip_bl_desc.elems = zip_BL_CODES;
+ zip_bl_desc.max_length = zip_MAX_BL_BITS;
+ zip_bl_desc.max_code = 0;
// Initialize the mapping length (0..255) -> length code (0..28)
length = 0;
- for(code = 0; code < zip_LENGTH_CODES-1; code++) {
- zip_base_length[code] = length;
- for(n = 0; n < (1< dist code (0..29) */
dist = 0;
- for(code = 0 ; code < 16; code++) {
- zip_base_dist[code] = dist;
- for(n = 0; n < (1<>= 7; // from now on, all distances are divided by 128
- for( ; code < zip_D_CODES; code++) {
- zip_base_dist[code] = dist << 7;
- for(n = 0; n < (1<<(zip_extra_dbits[code]-7)); n++)
- zip_dist_code[256 + dist++] = code;
+ for (; code < zip_D_CODES; code++) {
+ zip_base_dist[code] = dist << 7;
+ for (n = 0; n < 1 << (zip_extra_dbits[code] - 7); n++)
+ zip_dist_code[256 + dist++] = code;
}
// Assert (dist == 256, "ct_init: 256+dist != 512");
// Construct the codes of the static literal tree
- for(bits = 0; bits <= zip_MAX_BITS; bits++)
- zip_bl_count[bits] = 0;
+ for (bits = 0; bits <= zip_MAX_BITS; bits++) zip_bl_count[bits] = 0;
n = 0;
- while(n <= 143) { zip_static_ltree[n++].dl = 8; zip_bl_count[8]++; }
- while(n <= 255) { zip_static_ltree[n++].dl = 9; zip_bl_count[9]++; }
- while(n <= 279) { zip_static_ltree[n++].dl = 7; zip_bl_count[7]++; }
- while(n <= 287) { zip_static_ltree[n++].dl = 8; zip_bl_count[8]++; }
+ while (n <= 143) {
+ zip_static_ltree[n++].dl = 8;
+ zip_bl_count[8]++;
+ }
+ while (n <= 255) {
+ zip_static_ltree[n++].dl = 9;
+ zip_bl_count[9]++;
+ }
+ while (n <= 279) {
+ zip_static_ltree[n++].dl = 7;
+ zip_bl_count[7]++;
+ }
+ while (n <= 287) {
+ zip_static_ltree[n++].dl = 8;
+ zip_bl_count[8]++;
+ }
/* Codes 286 and 287 do not exist, but we must include them in the
* tree construction to get a canonical Huffman tree (longest code
* all ones)
@@ -930,157 +944,151 @@ function zip_ct_init() {
zip_gen_codes(zip_static_ltree, zip_L_CODES + 1);
/* The static distance tree is trivial: */
- for(n = 0; n < zip_D_CODES; n++) {
- zip_static_dtree[n].dl = 5;
- zip_static_dtree[n].fc = zip_bi_reverse(n, 5);
+ for (n = 0; n < zip_D_CODES; n++) {
+ zip_static_dtree[n].dl = 5;
+ zip_static_dtree[n].fc = zip_bi_reverse(n, 5);
}
// Initialize the first block of the first file:
zip_init_block();
-}
+ }
-/* ==========================================================================
- * Initialize a new block.
- */
-function zip_init_block() {
+ /* ==========================================================================
+ * Initialize a new block.
+ */
+ function zip_init_block() {
var n; // iterates over tree elements
// Initialize the trees.
- for(n = 0; n < zip_L_CODES; n++) zip_dyn_ltree[n].fc = 0;
- for(n = 0; n < zip_D_CODES; n++) zip_dyn_dtree[n].fc = 0;
- for(n = 0; n < zip_BL_CODES; n++) zip_bl_tree[n].fc = 0;
+ for (n = 0; n < zip_L_CODES; n++) zip_dyn_ltree[n].fc = 0;
+ for (n = 0; n < zip_D_CODES; n++) zip_dyn_dtree[n].fc = 0;
+ for (n = 0; n < zip_BL_CODES; n++) zip_bl_tree[n].fc = 0;
zip_dyn_ltree[zip_END_BLOCK].fc = 1;
zip_opt_len = zip_static_len = 0;
zip_last_lit = zip_last_dist = zip_last_flags = 0;
zip_flags = 0;
zip_flag_bit = 1;
-}
+ }
-/* ==========================================================================
- * Restore the heap property by moving down the tree starting at node k,
- * exchanging a node with the smallest of its two sons if necessary, stopping
- * when the heap property is re-established (each father smaller than its
- * two sons).
- */
-function zip_pqdownheap(
- tree, // the tree to restore
- k) { // node to move down
+ /* ==========================================================================
+ * Restore the heap property by moving down the tree starting at node k,
+ * exchanging a node with the smallest of its two sons if necessary, stopping
+ * when the heap property is re-established (each father smaller than its
+ * two sons).
+ */
+ function zip_pqdownheap(
+ tree, // the tree to restore
+ k
+ ) {
+ // node to move down
var v = zip_heap[k];
- var j = k << 1; // left son of k
+ var j = k << 1; // left son of k
- while(j <= zip_heap_len) {
- // Set j to the smallest of the two sons:
- if(j < zip_heap_len &&
- zip_SMALLER(tree, zip_heap[j + 1], zip_heap[j]))
- j++;
+ while (j <= zip_heap_len) {
+ // Set j to the smallest of the two sons:
+ if (j < zip_heap_len && zip_SMALLER(tree, zip_heap[j + 1], zip_heap[j]))
+ j++;
- // Exit if v is smaller than both sons
- if(zip_SMALLER(tree, v, zip_heap[j]))
- break;
+ // Exit if v is smaller than both sons
+ if (zip_SMALLER(tree, v, zip_heap[j])) break;
- // Exchange v with the smallest son
- zip_heap[k] = zip_heap[j];
- k = j;
+ // Exchange v with the smallest son
+ zip_heap[k] = zip_heap[j];
+ k = j;
- // And continue down the tree, setting j to the left son of k
- j <<= 1;
+ // And continue down the tree, setting j to the left son of k
+ j <<= 1;
}
zip_heap[k] = v;
-}
-
-/* ==========================================================================
- * Compute the optimal bit lengths for a tree and update the total bit length
- * for the current block.
- * IN assertion: the fields freq and dad are set, heap[heap_max] and
- * above are the tree nodes sorted by increasing frequency.
- * OUT assertions: the field len is set to the optimal bit length, the
- * array bl_count contains the frequencies for each bit length.
- * The length opt_len is updated; static_len is also updated if stree is
- * not null.
- */
-function zip_gen_bitlen(desc) { // the tree descriptor
- var tree = desc.dyn_tree;
- var extra = desc.extra_bits;
- var base = desc.extra_base;
- var max_code = desc.max_code;
- var max_length = desc.max_length;
- var stree = desc.static_tree;
- var h; // heap index
- var n, m; // iterate over the tree elements
- var bits; // bit length
- var xbits; // extra bits
- var f; // frequency
- var overflow = 0; // number of elements with bit length too large
-
- for(bits = 0; bits <= zip_MAX_BITS; bits++)
- zip_bl_count[bits] = 0;
+ }
+
+ /* ==========================================================================
+ * Compute the optimal bit lengths for a tree and update the total bit length
+ * for the current block.
+ * IN assertion: the fields freq and dad are set, heap[heap_max] and
+ * above are the tree nodes sorted by increasing frequency.
+ * OUT assertions: the field len is set to the optimal bit length, the
+ * array bl_count contains the frequencies for each bit length.
+ * The length opt_len is updated; static_len is also updated if stree is
+ * not null.
+ */
+ function zip_gen_bitlen(desc) {
+ // the tree descriptor
+ var tree = desc.dyn_tree;
+ var extra = desc.extra_bits;
+ var base = desc.extra_base;
+ var max_code = desc.max_code;
+ var max_length = desc.max_length;
+ var stree = desc.static_tree;
+ var h; // heap index
+ var n, m; // iterate over the tree elements
+ var bits; // bit length
+ var xbits; // extra bits
+ var f; // frequency
+ var overflow = 0; // number of elements with bit length too large
+
+ for (bits = 0; bits <= zip_MAX_BITS; bits++) zip_bl_count[bits] = 0;
/* In a first pass, compute the optimal bit lengths (which may
* overflow in the case of the bit length tree).
*/
tree[zip_heap[zip_heap_max]].dl = 0; // root of the heap
- for(h = zip_heap_max + 1; h < zip_HEAP_SIZE; h++) {
- n = zip_heap[h];
- bits = tree[tree[n].dl].dl + 1;
- if(bits > max_length) {
- bits = max_length;
- overflow++;
- }
- tree[n].dl = bits;
- // We overwrite tree[n].dl which is no longer needed
-
- if(n > max_code)
- continue; // not a leaf node
-
- zip_bl_count[bits]++;
- xbits = 0;
- if(n >= base)
- xbits = extra[n - base];
- f = tree[n].fc;
- zip_opt_len += f * (bits + xbits);
- if(stree != null)
- zip_static_len += f * (stree[n].dl + xbits);
+ for (h = zip_heap_max + 1; h < zip_HEAP_SIZE; h++) {
+ n = zip_heap[h];
+ bits = tree[tree[n].dl].dl + 1;
+ if (bits > max_length) {
+ bits = max_length;
+ overflow++;
+ }
+ tree[n].dl = bits;
+ // We overwrite tree[n].dl which is no longer needed
+
+ if (n > max_code) continue; // not a leaf node
+
+ zip_bl_count[bits]++;
+ xbits = 0;
+ if (n >= base) xbits = extra[n - base];
+ f = tree[n].fc;
+ zip_opt_len += f * (bits + xbits);
+ if (stree != null) zip_static_len += f * (stree[n].dl + xbits);
}
- if(overflow == 0)
- return;
+ if (overflow == 0) return;
// This happens for example on obj2 and pic of the Calgary corpus
// Find the first bit length which could increase:
do {
- bits = max_length - 1;
- while(zip_bl_count[bits] == 0)
- bits--;
- zip_bl_count[bits]--; // move one leaf down the tree
- zip_bl_count[bits + 1] += 2; // move one overflow item as its brother
- zip_bl_count[max_length]--;
- /* The brother of the overflow item also moves one step up,
- * but this does not affect bl_count[max_length]
- */
- overflow -= 2;
- } while(overflow > 0);
+ bits = max_length - 1;
+ while (zip_bl_count[bits] == 0) bits--;
+ zip_bl_count[bits]--; // move one leaf down the tree
+ zip_bl_count[bits + 1] += 2; // move one overflow item as its brother
+ zip_bl_count[max_length]--;
+ /* The brother of the overflow item also moves one step up,
+ * but this does not affect bl_count[max_length]
+ */
+ overflow -= 2;
+ } while (overflow > 0);
/* Now recompute all bit lengths, scanning in increasing frequency.
* h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
* lengths instead of fixing only the wrong ones. This idea is taken
* from 'ar' written by Haruhiko Okumura.)
*/
- for(bits = max_length; bits != 0; bits--) {
- n = zip_bl_count[bits];
- while(n != 0) {
- m = zip_heap[--h];
- if(m > max_code)
- continue;
- if(tree[m].dl != bits) {
- zip_opt_len += (bits - tree[m].dl) * tree[m].fc;
- tree[m].fc = bits;
- }
- n--;
- }
+ for (bits = max_length; bits != 0; bits--) {
+ n = zip_bl_count[bits];
+ while (n != 0) {
+ m = zip_heap[--h];
+ if (m > max_code) continue;
+ if (tree[m].dl != bits) {
+ zip_opt_len += (bits - tree[m].dl) * tree[m].fc;
+ tree[m].fc = bits;
+ }
+ n--;
+ }
}
-}
+ }
/* ==========================================================================
* Generate the codes for a given tree and bit counts (which need not be
@@ -1090,55 +1098,58 @@ function zip_gen_bitlen(desc) { // the tree descriptor
* OUT assertion: the field code is set for all tree elements of non
* zero code length.
*/
-function zip_gen_codes(tree, // the tree to decorate
- max_code) { // largest code with non zero frequency
- var next_code = new Array(zip_MAX_BITS+1); // next code value for each bit length
- var code = 0; // running code value
- var bits; // bit index
- var n; // code index
+ function zip_gen_codes(
+ tree, // the tree to decorate
+ max_code
+ ) {
+ // largest code with non zero frequency
+ var next_code = new Array(zip_MAX_BITS + 1); // next code value for each bit length
+ var code = 0; // running code value
+ var bits; // bit index
+ var n; // code index
/* The distribution counts are first used to generate the code values
* without bit reversal.
*/
- for(bits = 1; bits <= zip_MAX_BITS; bits++) {
- code = ((code + zip_bl_count[bits-1]) << 1);
- next_code[bits] = code;
+ for (bits = 1; bits <= zip_MAX_BITS; bits++) {
+ code = (code + zip_bl_count[bits - 1]) << 1;
+ next_code[bits] = code;
}
/* Check that the bit counts in bl_count are consistent. The last code
* must be all ones.
*/
-// Assert (code + encoder->bl_count[MAX_BITS]-1 == (1<bl_count[MAX_BITS]-1 == (1<> 1; n >= 1; n--)
- zip_pqdownheap(tree, n);
+ for (n = zip_heap_len >> 1; n >= 1; n--) zip_pqdownheap(tree, n);
/* Construct the Huffman tree by repeatedly combining the least two
* frequent nodes.
*/
do {
- n = zip_heap[zip_SMALLEST];
- zip_heap[zip_SMALLEST] = zip_heap[zip_heap_len--];
- zip_pqdownheap(tree, zip_SMALLEST);
+ n = zip_heap[zip_SMALLEST];
+ zip_heap[zip_SMALLEST] = zip_heap[zip_heap_len--];
+ zip_pqdownheap(tree, zip_SMALLEST);
- m = zip_heap[zip_SMALLEST]; // m = node of next least frequency
+ m = zip_heap[zip_SMALLEST]; // m = node of next least frequency
- // keep the nodes sorted by frequency
- zip_heap[--zip_heap_max] = n;
- zip_heap[--zip_heap_max] = m;
+ // keep the nodes sorted by frequency
+ zip_heap[--zip_heap_max] = n;
+ zip_heap[--zip_heap_max] = m;
- // Create a new node father of n and m
- tree[node].fc = tree[n].fc + tree[m].fc;
-// depth[node] = (char)(MAX(depth[n], depth[m]) + 1);
- if(zip_depth[n] > zip_depth[m] + 1)
- zip_depth[node] = zip_depth[n];
- else
- zip_depth[node] = zip_depth[m] + 1;
- tree[n].dl = tree[m].dl = node;
+ // Create a new node father of n and m
+ tree[node].fc = tree[n].fc + tree[m].fc;
+ // depth[node] = (char)(MAX(depth[n], depth[m]) + 1);
+ if (zip_depth[n] > zip_depth[m] + 1) zip_depth[node] = zip_depth[n];
+ else zip_depth[node] = zip_depth[m] + 1;
+ tree[n].dl = tree[m].dl = node;
- // and insert the new node in the heap
- zip_heap[zip_SMALLEST] = node++;
- zip_pqdownheap(tree, zip_SMALLEST);
-
- } while(zip_heap_len >= 2);
+ // and insert the new node in the heap
+ zip_heap[zip_SMALLEST] = node++;
+ zip_pqdownheap(tree, zip_SMALLEST);
+ } while (zip_heap_len >= 2);
zip_heap[--zip_heap_max] = zip_heap[zip_SMALLEST];
@@ -1215,122 +1220,126 @@ function zip_build_tree(desc) { // the tree descriptor
// The field len is now set, we can generate the bit codes
zip_gen_codes(tree, max_code);
-}
+ }
-/* ==========================================================================
- * Scan a literal or distance tree to determine the frequencies of the codes
- * in the bit length tree. Updates opt_len to take into account the repeat
- * counts. (The contribution of the bit length codes will be added later
- * during the construction of bl_tree.)
- */
-function zip_scan_tree(tree,// the tree to be scanned
- max_code) { // and its largest code of non zero frequency
- var n; // iterates over all tree elements
- var prevlen = -1; // last emitted length
- var curlen; // length of current code
- var nextlen = tree[0].dl; // length of next code
- var count = 0; // repeat count of the current code
- var max_count = 7; // max repeat count
- var min_count = 4; // min repeat count
-
- if(nextlen == 0) {
- max_count = 138;
- min_count = 3;
+ /* ==========================================================================
+ * Scan a literal or distance tree to determine the frequencies of the codes
+ * in the bit length tree. Updates opt_len to take into account the repeat
+ * counts. (The contribution of the bit length codes will be added later
+ * during the construction of bl_tree.)
+ */
+ function zip_scan_tree(
+ tree, // the tree to be scanned
+ max_code
+ ) {
+ // and its largest code of non zero frequency
+ var n; // iterates over all tree elements
+ var prevlen = -1; // last emitted length
+ var curlen; // length of current code
+ var nextlen = tree[0].dl; // length of next code
+ var count = 0; // repeat count of the current code
+ var max_count = 7; // max repeat count
+ var min_count = 4; // min repeat count
+
+ if (nextlen == 0) {
+ max_count = 138;
+ min_count = 3;
}
tree[max_code + 1].dl = 0xffff; // guard
- for(n = 0; n <= max_code; n++) {
- curlen = nextlen;
- nextlen = tree[n + 1].dl;
- if(++count < max_count && curlen == nextlen)
- continue;
- else if(count < min_count)
- zip_bl_tree[curlen].fc += count;
- else if(curlen != 0) {
- if(curlen != prevlen)
- zip_bl_tree[curlen].fc++;
- zip_bl_tree[zip_REP_3_6].fc++;
- } else if(count <= 10)
- zip_bl_tree[zip_REPZ_3_10].fc++;
- else
- zip_bl_tree[zip_REPZ_11_138].fc++;
- count = 0; prevlen = curlen;
- if(nextlen == 0) {
- max_count = 138;
- min_count = 3;
- } else if(curlen == nextlen) {
- max_count = 6;
- min_count = 3;
- } else {
- max_count = 7;
- min_count = 4;
- }
+ for (n = 0; n <= max_code; n++) {
+ curlen = nextlen;
+ nextlen = tree[n + 1].dl;
+ if (++count < max_count && curlen == nextlen) continue;
+ else if (count < min_count) zip_bl_tree[curlen].fc += count;
+ else if (curlen != 0) {
+ if (curlen != prevlen) zip_bl_tree[curlen].fc++;
+ zip_bl_tree[zip_REP_3_6].fc++;
+ } else if (count <= 10) zip_bl_tree[zip_REPZ_3_10].fc++;
+ else zip_bl_tree[zip_REPZ_11_138].fc++;
+ count = 0;
+ prevlen = curlen;
+ if (nextlen == 0) {
+ max_count = 138;
+ min_count = 3;
+ } else if (curlen == nextlen) {
+ max_count = 6;
+ min_count = 3;
+ } else {
+ max_count = 7;
+ min_count = 4;
+ }
}
-}
+ }
/* ==========================================================================
* Send a literal or distance tree in compressed form, using the codes in
* bl_tree.
*/
-function zip_send_tree(tree, // the tree to be scanned
- max_code) { // and its largest code of non zero frequency
- var n; // iterates over all tree elements
- var prevlen = -1; // last emitted length
- var curlen; // length of current code
- var nextlen = tree[0].dl; // length of next code
- var count = 0; // repeat count of the current code
- var max_count = 7; // max repeat count
- var min_count = 4; // min repeat count
-
- /* tree[max_code+1].dl = -1; */ /* guard already set */
- if(nextlen == 0) {
+ function zip_send_tree(
+ tree, // the tree to be scanned
+ max_code
+ ) {
+ // and its largest code of non zero frequency
+ var n; // iterates over all tree elements
+ var prevlen = -1; // last emitted length
+ var curlen; // length of current code
+ var nextlen = tree[0].dl; // length of next code
+ var count = 0; // repeat count of the current code
+ var max_count = 7; // max repeat count
+ var min_count = 4; // min repeat count
+
+ /* tree[max_code+1].dl = -1; */ /* guard already set */
+ if (nextlen == 0) {
max_count = 138;
min_count = 3;
}
- for(n = 0; n <= max_code; n++) {
- curlen = nextlen;
- nextlen = tree[n+1].dl;
- if(++count < max_count && curlen == nextlen) {
- continue;
- } else if(count < min_count) {
- do { zip_SEND_CODE(curlen, zip_bl_tree); } while(--count != 0);
- } else if(curlen != 0) {
- if(curlen != prevlen) {
- zip_SEND_CODE(curlen, zip_bl_tree);
- count--;
- }
- // Assert(count >= 3 && count <= 6, " 3_6?");
- zip_SEND_CODE(zip_REP_3_6, zip_bl_tree);
- zip_send_bits(count - 3, 2);
- } else if(count <= 10) {
- zip_SEND_CODE(zip_REPZ_3_10, zip_bl_tree);
- zip_send_bits(count-3, 3);
- } else {
- zip_SEND_CODE(zip_REPZ_11_138, zip_bl_tree);
- zip_send_bits(count-11, 7);
- }
- count = 0;
- prevlen = curlen;
- if(nextlen == 0) {
- max_count = 138;
- min_count = 3;
- } else if(curlen == nextlen) {
- max_count = 6;
- min_count = 3;
- } else {
- max_count = 7;
- min_count = 4;
- }
+ for (n = 0; n <= max_code; n++) {
+ curlen = nextlen;
+ nextlen = tree[n + 1].dl;
+ if (++count < max_count && curlen == nextlen) {
+ continue;
+ } else if (count < min_count) {
+ do {
+ zip_SEND_CODE(curlen, zip_bl_tree);
+ } while (--count != 0);
+ } else if (curlen != 0) {
+ if (curlen != prevlen) {
+ zip_SEND_CODE(curlen, zip_bl_tree);
+ count--;
+ }
+ // Assert(count >= 3 && count <= 6, " 3_6?");
+ zip_SEND_CODE(zip_REP_3_6, zip_bl_tree);
+ zip_send_bits(count - 3, 2);
+ } else if (count <= 10) {
+ zip_SEND_CODE(zip_REPZ_3_10, zip_bl_tree);
+ zip_send_bits(count - 3, 3);
+ } else {
+ zip_SEND_CODE(zip_REPZ_11_138, zip_bl_tree);
+ zip_send_bits(count - 11, 7);
+ }
+ count = 0;
+ prevlen = curlen;
+ if (nextlen == 0) {
+ max_count = 138;
+ min_count = 3;
+ } else if (curlen == nextlen) {
+ max_count = 6;
+ min_count = 3;
+ } else {
+ max_count = 7;
+ min_count = 4;
+ }
}
-}
+ }
-/* ==========================================================================
- * Construct the Huffman tree for the bit lengths and return the index in
- * bl_order of the last bit length code to send.
- */
-function zip_build_bl_tree() {
- var max_blindex; // index of last bit length code of non zero freq
+ /* ==========================================================================
+ * Construct the Huffman tree for the bit lengths and return the index in
+ * bl_order of the last bit length code to send.
+ */
+ function zip_build_bl_tree() {
+ var max_blindex; // index of last bit length code of non zero freq
// Determine the bit length frequencies for literal and distance trees
zip_scan_tree(zip_dyn_ltree, zip_l_desc.max_code);
@@ -1346,64 +1355,66 @@ function zip_build_bl_tree() {
* requires that at least 4 bit length codes be sent. (appnote.txt says
* 3 but the actual value used is 4.)
*/
- for(max_blindex = zip_BL_CODES-1; max_blindex >= 3; max_blindex--) {
- if(zip_bl_tree[zip_bl_order[max_blindex]].dl != 0) break;
+ for (max_blindex = zip_BL_CODES - 1; max_blindex >= 3; max_blindex--) {
+ if (zip_bl_tree[zip_bl_order[max_blindex]].dl != 0) break;
}
/* Update opt_len to include the bit length tree and counts */
- zip_opt_len += 3*(max_blindex+1) + 5+5+4;
-// Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
-// encoder->opt_len, encoder->static_len));
+ zip_opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
+ // Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
+ // encoder->opt_len, encoder->static_len));
return max_blindex;
-}
+ }
-/* ==========================================================================
- * Send the header for a block using dynamic Huffman trees: the counts, the
- * lengths of the bit length codes, the literal tree and the distance tree.
- * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
- */
-function zip_send_all_trees(lcodes, dcodes, blcodes) { // number of codes for each tree
+ /* ==========================================================================
+ * Send the header for a block using dynamic Huffman trees: the counts, the
+ * lengths of the bit length codes, the literal tree and the distance tree.
+ * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
+ */
+ function zip_send_all_trees(lcodes, dcodes, blcodes) {
+ // number of codes for each tree
var rank; // index in bl_order
-// Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
-// Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
-// "too many codes");
-// Tracev((stderr, "\nbl counts: "));
- zip_send_bits(lcodes-257, 5); // not +255 as stated in appnote.txt
- zip_send_bits(dcodes-1, 5);
- zip_send_bits(blcodes-4, 4); // not -3 as stated in appnote.txt
- for(rank = 0; rank < blcodes; rank++) {
-// Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
- zip_send_bits(zip_bl_tree[zip_bl_order[rank]].dl, 3);
+ // Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
+ // Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
+ // "too many codes");
+ // Tracev((stderr, "\nbl counts: "));
+ zip_send_bits(lcodes - 257, 5); // not +255 as stated in appnote.txt
+ zip_send_bits(dcodes - 1, 5);
+ zip_send_bits(blcodes - 4, 4); // not -3 as stated in appnote.txt
+ for (rank = 0; rank < blcodes; rank++) {
+ // Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
+ zip_send_bits(zip_bl_tree[zip_bl_order[rank]].dl, 3);
}
// send the literal tree
- zip_send_tree(zip_dyn_ltree,lcodes-1);
+ zip_send_tree(zip_dyn_ltree, lcodes - 1);
// send the distance tree
- zip_send_tree(zip_dyn_dtree,dcodes-1);
-}
+ zip_send_tree(zip_dyn_dtree, dcodes - 1);
+ }
-/* ==========================================================================
- * Determine the best encoding for the current block: dynamic trees, static
- * trees or store, and output the encoded block to the zip file.
- */
-function zip_flush_block(eof) { // true if this is the last block for a file
+ /* ==========================================================================
+ * Determine the best encoding for the current block: dynamic trees, static
+ * trees or store, and output the encoded block to the zip file.
+ */
+ function zip_flush_block(eof) {
+ // true if this is the last block for a file
var opt_lenb, static_lenb; // opt_len and static_len in bytes
- var max_blindex; // index of last bit length code of non zero freq
- var stored_len; // length of input block
+ var max_blindex; // index of last bit length code of non zero freq
+ var stored_len; // length of input block
stored_len = zip_strstart - zip_block_start;
zip_flag_buf[zip_last_flags] = zip_flags; // Save the flags for the last 8 items
// Construct the literal and distance trees
zip_build_tree(zip_l_desc);
-// Tracev((stderr, "\nlit data: dyn %ld, stat %ld",
-// encoder->opt_len, encoder->static_len));
+ // Tracev((stderr, "\nlit data: dyn %ld, stat %ld",
+ // encoder->opt_len, encoder->static_len));
zip_build_tree(zip_d_desc);
-// Tracev((stderr, "\ndist data: dyn %ld, stat %ld",
-// encoder->opt_len, encoder->static_len));
+ // Tracev((stderr, "\ndist data: dyn %ld, stat %ld",
+ // encoder->opt_len, encoder->static_len));
/* At this point, opt_len and static_len are the total bit lengths of
* the compressed block data, excluding the tree representations.
*/
@@ -1414,257 +1425,264 @@ function zip_flush_block(eof) { // true if this is the last block for a file
max_blindex = zip_build_bl_tree();
// Determine the best encoding. Compute first the block length in bytes
- opt_lenb = (zip_opt_len +3+7)>>3;
- static_lenb = (zip_static_len+3+7)>>3;
-
-// Trace((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ",
-// opt_lenb, encoder->opt_len,
-// static_lenb, encoder->static_len, stored_len,
-// encoder->last_lit, encoder->last_dist));
-
- if(static_lenb <= opt_lenb)
- opt_lenb = static_lenb;
- if(stored_len + 4 <= opt_lenb // 4: two words for the lengths
- && zip_block_start >= 0) {
- var i;
-
- /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
- * Otherwise we can't have processed more than WSIZE input bytes since
- * the last block flush, because compression would have been
- * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
- * transform a block into a stored block.
- */
- zip_send_bits((zip_STORED_BLOCK<<1)+eof, 3); /* send block type */
- zip_bi_windup(); /* align on byte boundary */
- zip_put_short(stored_len);
- zip_put_short(~stored_len);
+ opt_lenb = (zip_opt_len + 3 + 7) >> 3;
+ static_lenb = (zip_static_len + 3 + 7) >> 3;
+
+ // Trace((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ",
+ // opt_lenb, encoder->opt_len,
+ // static_lenb, encoder->static_len, stored_len,
+ // encoder->last_lit, encoder->last_dist));
+
+ if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
+ if (
+ stored_len + 4 <= opt_lenb && // 4: two words for the lengths
+ zip_block_start >= 0
+ ) {
+ var i;
+
+ /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
+ * Otherwise we can't have processed more than WSIZE input bytes since
+ * the last block flush, because compression would have been
+ * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
+ * transform a block into a stored block.
+ */
+ zip_send_bits((zip_STORED_BLOCK << 1) + eof, 3); /* send block type */
+ zip_bi_windup(); /* align on byte boundary */
+ zip_put_short(stored_len);
+ zip_put_short(~stored_len);
// copy block
-/*
+ /*
p = &window[block_start];
for(i = 0; i < stored_len; i++)
put_byte(p[i]);
*/
- for(i = 0; i < stored_len; i++)
- zip_put_byte(zip_window[zip_block_start + i]);
-
- } else if(static_lenb == opt_lenb) {
- zip_send_bits((zip_STATIC_TREES<<1)+eof, 3);
- zip_compress_block(zip_static_ltree, zip_static_dtree);
+ for (i = 0; i < stored_len; i++)
+ zip_put_byte(zip_window[zip_block_start + i]);
+ } else if (static_lenb == opt_lenb) {
+ zip_send_bits((zip_STATIC_TREES << 1) + eof, 3);
+ zip_compress_block(zip_static_ltree, zip_static_dtree);
} else {
- zip_send_bits((zip_DYN_TREES<<1)+eof, 3);
- zip_send_all_trees(zip_l_desc.max_code+1,
- zip_d_desc.max_code+1,
- max_blindex+1);
- zip_compress_block(zip_dyn_ltree, zip_dyn_dtree);
+ zip_send_bits((zip_DYN_TREES << 1) + eof, 3);
+ zip_send_all_trees(
+ zip_l_desc.max_code + 1,
+ zip_d_desc.max_code + 1,
+ max_blindex + 1
+ );
+ zip_compress_block(zip_dyn_ltree, zip_dyn_dtree);
}
zip_init_block();
- if(eof != 0)
- zip_bi_windup();
-}
+ if (eof != 0) zip_bi_windup();
+ }
-/* ==========================================================================
- * Save the match info and tally the frequency counts. Return true if
- * the current block must be flushed.
- */
-function zip_ct_tally(
- dist, // distance of matched string
- lc) { // match length-MIN_MATCH or unmatched char (if dist==0)
+ /* ==========================================================================
+ * Save the match info and tally the frequency counts. Return true if
+ * the current block must be flushed.
+ */
+ function zip_ct_tally(
+ dist, // distance of matched string
+ lc
+ ) {
+ // match length-MIN_MATCH or unmatched char (if dist==0)
zip_l_buf[zip_last_lit++] = lc;
- if(dist == 0) {
- // lc is the unmatched char
- zip_dyn_ltree[lc].fc++;
+ if (dist == 0) {
+ // lc is the unmatched char
+ zip_dyn_ltree[lc].fc++;
} else {
- // Here, lc is the match length - MIN_MATCH
- dist--; // dist = match distance - 1
-// Assert((ush)dist < (ush)MAX_DIST &&
-// (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
-// (ush)D_CODE(dist) < (ush)D_CODES, "ct_tally: bad match");
+ // Here, lc is the match length - MIN_MATCH
+ dist--; // dist = match distance - 1
+ // Assert((ush)dist < (ush)MAX_DIST &&
+ // (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
+ // (ush)D_CODE(dist) < (ush)D_CODES, "ct_tally: bad match");
- zip_dyn_ltree[zip_length_code[lc]+zip_LITERALS+1].fc++;
- zip_dyn_dtree[zip_D_CODE(dist)].fc++;
+ zip_dyn_ltree[zip_length_code[lc] + zip_LITERALS + 1].fc++;
+ zip_dyn_dtree[zip_D_CODE(dist)].fc++;
- zip_d_buf[zip_last_dist++] = dist;
- zip_flags |= zip_flag_bit;
+ zip_d_buf[zip_last_dist++] = dist;
+ zip_flags |= zip_flag_bit;
}
zip_flag_bit <<= 1;
// Output the flags if they fill a byte
- if((zip_last_lit & 7) == 0) {
- zip_flag_buf[zip_last_flags++] = zip_flags;
- zip_flags = 0;
- zip_flag_bit = 1;
+ if ((zip_last_lit & 7) == 0) {
+ zip_flag_buf[zip_last_flags++] = zip_flags;
+ zip_flags = 0;
+ zip_flag_bit = 1;
}
// Try to guess if it is profitable to stop the current block here
- if(zip_compr_level > 2 && (zip_last_lit & 0xfff) == 0) {
- // Compute an upper bound for the compressed length
- var out_length = zip_last_lit * 8;
- var in_length = zip_strstart - zip_block_start;
- var dcode;
-
- for(dcode = 0; dcode < zip_D_CODES; dcode++) {
- out_length += zip_dyn_dtree[dcode].fc * (5 + zip_extra_dbits[dcode]);
- }
- out_length >>= 3;
-// Trace((stderr,"\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ",
-// encoder->last_lit, encoder->last_dist, in_length, out_length,
-// 100L - out_length*100L/in_length));
- if(zip_last_dist < parseInt(zip_last_lit/2) &&
- out_length < parseInt(in_length/2))
- return true;
+ if (zip_compr_level > 2 && (zip_last_lit & 0xfff) == 0) {
+ // Compute an upper bound for the compressed length
+ var out_length = zip_last_lit * 8;
+ var in_length = zip_strstart - zip_block_start;
+ var dcode;
+
+ for (dcode = 0; dcode < zip_D_CODES; dcode++) {
+ out_length += zip_dyn_dtree[dcode].fc * (5 + zip_extra_dbits[dcode]);
+ }
+ out_length >>= 3;
+ // Trace((stderr,"\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ",
+ // encoder->last_lit, encoder->last_dist, in_length, out_length,
+ // 100L - out_length*100L/in_length));
+ if (
+ zip_last_dist < parseInt(zip_last_lit / 2) &&
+ out_length < parseInt(in_length / 2)
+ )
+ return true;
}
- return (zip_last_lit == zip_LIT_BUFSIZE-1 ||
- zip_last_dist == zip_DIST_BUFSIZE);
+ return (
+ zip_last_lit == zip_LIT_BUFSIZE - 1 || zip_last_dist == zip_DIST_BUFSIZE
+ );
/* 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.
*/
-}
+ }
/* ==========================================================================
* Send the block data compressed using the given Huffman trees
*/
-function zip_compress_block(
- ltree, // literal tree
- dtree) { // distance tree
- var dist; // distance of matched string
- var lc; // match length or unmatched char (if dist == 0)
- var lx = 0; // running index in l_buf
- var dx = 0; // running index in d_buf
- var fx = 0; // running index in flag_buf
- var flag = 0; // current flags
- var code; // the code to send
- var extra; // number of extra bits to send
-
- if(zip_last_lit != 0) do {
- if((lx & 7) == 0)
- flag = zip_flag_buf[fx++];
- lc = zip_l_buf[lx++] & 0xff;
- if((flag & 1) == 0) {
- zip_SEND_CODE(lc, ltree); /* send a literal byte */
-// Tracecv(isgraph(lc), (stderr," '%c' ", lc));
- } else {
- // Here, lc is the match length - MIN_MATCH
- code = zip_length_code[lc];
- zip_SEND_CODE(code+zip_LITERALS+1, ltree); // send the length code
- extra = zip_extra_lbits[code];
- if(extra != 0) {
- lc -= zip_base_length[code];
- zip_send_bits(lc, extra); // send the extra length bits
- }
- dist = zip_d_buf[dx++];
- // Here, dist is the match distance - 1
- code = zip_D_CODE(dist);
-// Assert (code < D_CODES, "bad d_code");
-
- zip_SEND_CODE(code, dtree); // send the distance code
- extra = zip_extra_dbits[code];
- if(extra != 0) {
- dist -= zip_base_dist[code];
- zip_send_bits(dist, extra); // send the extra distance bits
- }
- } // literal or match pair ?
- flag >>= 1;
- } while(lx < zip_last_lit);
+ function zip_compress_block(
+ ltree, // literal tree
+ dtree
+ ) {
+ // distance tree
+ var dist; // distance of matched string
+ var lc; // match length or unmatched char (if dist == 0)
+ var lx = 0; // running index in l_buf
+ var dx = 0; // running index in d_buf
+ var fx = 0; // running index in flag_buf
+ var flag = 0; // current flags
+ var code; // the code to send
+ var extra; // number of extra bits to send
+
+ if (zip_last_lit != 0)
+ do {
+ if ((lx & 7) == 0) flag = zip_flag_buf[fx++];
+ lc = zip_l_buf[lx++] & 0xff;
+ if ((flag & 1) == 0) {
+ zip_SEND_CODE(lc, ltree); /* send a literal byte */
+ // Tracecv(isgraph(lc), (stderr," '%c' ", lc));
+ } else {
+ // Here, lc is the match length - MIN_MATCH
+ code = zip_length_code[lc];
+ zip_SEND_CODE(code + zip_LITERALS + 1, ltree); // send the length code
+ extra = zip_extra_lbits[code];
+ if (extra != 0) {
+ lc -= zip_base_length[code];
+ zip_send_bits(lc, extra); // send the extra length bits
+ }
+ dist = zip_d_buf[dx++];
+ // Here, dist is the match distance - 1
+ code = zip_D_CODE(dist);
+ // Assert (code < D_CODES, "bad d_code");
+
+ zip_SEND_CODE(code, dtree); // send the distance code
+ extra = zip_extra_dbits[code];
+ if (extra != 0) {
+ dist -= zip_base_dist[code];
+ zip_send_bits(dist, extra); // send the extra distance bits
+ }
+ } // literal or match pair ?
+ flag >>= 1;
+ } while (lx < zip_last_lit);
zip_SEND_CODE(zip_END_BLOCK, ltree);
-}
+ }
-/* ==========================================================================
- * Send a value on a given number of bits.
- * IN assertion: length <= 16 and value fits in length bits.
- */
-var zip_Buf_size = 16; // bit size of bi_buf
-function zip_send_bits(
- value, // value to send
- length) { // number of bits
+ /* ==========================================================================
+ * Send a value on a given number of bits.
+ * IN assertion: length <= 16 and value fits in length bits.
+ */
+ var zip_Buf_size = 16; // bit size of bi_buf
+ function zip_send_bits(
+ value, // value to send
+ length
+ ) {
+ // number of bits
/* If not enough room in bi_buf, use (valid) bits from bi_buf and
* (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
* unused bits in value.
*/
- if(zip_bi_valid > zip_Buf_size - length) {
- zip_bi_buf |= (value << zip_bi_valid);
- zip_put_short(zip_bi_buf);
- zip_bi_buf = (value >> (zip_Buf_size - zip_bi_valid));
- zip_bi_valid += length - zip_Buf_size;
+ if (zip_bi_valid > zip_Buf_size - length) {
+ zip_bi_buf |= value << zip_bi_valid;
+ zip_put_short(zip_bi_buf);
+ zip_bi_buf = value >> (zip_Buf_size - zip_bi_valid);
+ zip_bi_valid += length - zip_Buf_size;
} else {
- zip_bi_buf |= value << zip_bi_valid;
- zip_bi_valid += length;
+ zip_bi_buf |= value << zip_bi_valid;
+ zip_bi_valid += length;
}
-}
+ }
-/* ==========================================================================
- * Reverse the first len bits of a code, using straightforward code (a faster
- * method would use a table)
- * IN assertion: 1 <= len <= 15
- */
-function zip_bi_reverse(
- code, // the value to invert
- len) { // its bit length
+ /* ==========================================================================
+ * Reverse the first len bits of a code, using straightforward code (a faster
+ * method would use a table)
+ * IN assertion: 1 <= len <= 15
+ */
+ function zip_bi_reverse(
+ code, // the value to invert
+ len
+ ) {
+ // its bit length
var res = 0;
do {
- res |= code & 1;
- code >>= 1;
- res <<= 1;
- } while(--len > 0);
+ res |= code & 1;
+ code >>= 1;
+ res <<= 1;
+ } while (--len > 0);
return res >> 1;
-}
+ }
-/* ==========================================================================
- * Write out any remaining bits in an incomplete byte.
- */
-function zip_bi_windup() {
- if(zip_bi_valid > 8) {
- zip_put_short(zip_bi_buf);
- } else if(zip_bi_valid > 0) {
- zip_put_byte(zip_bi_buf);
+ /* ==========================================================================
+ * Write out any remaining bits in an incomplete byte.
+ */
+ function zip_bi_windup() {
+ if (zip_bi_valid > 8) {
+ zip_put_short(zip_bi_buf);
+ } else if (zip_bi_valid > 0) {
+ zip_put_byte(zip_bi_buf);
}
zip_bi_buf = 0;
zip_bi_valid = 0;
-}
-
-function zip_qoutbuf() {
- if(zip_outcnt != 0) {
- var q, i;
- q = zip_new_queue();
- if(zip_qhead == null)
- zip_qhead = zip_qtail = q;
- else
- zip_qtail = zip_qtail.next = q;
- q.len = zip_outcnt - zip_outoff;
-// System.arraycopy(zip_outbuf, zip_outoff, q.ptr, 0, q.len);
- for(i = 0; i < q.len; i++)
- q.ptr[i] = zip_outbuf[zip_outoff + i];
- zip_outcnt = zip_outoff = 0;
+ }
+
+ function zip_qoutbuf() {
+ if (zip_outcnt != 0) {
+ var q, i;
+ q = zip_new_queue();
+ if (zip_qhead == null) zip_qhead = zip_qtail = q;
+ else zip_qtail = zip_qtail.next = q;
+ q.len = zip_outcnt - zip_outoff;
+ // System.arraycopy(zip_outbuf, zip_outoff, q.ptr, 0, q.len);
+ for (i = 0; i < q.len; i++) q.ptr[i] = zip_outbuf[zip_outoff + i];
+ zip_outcnt = zip_outoff = 0;
}
-}
+ }
-return function deflate(str, level) {
+ return function deflate(str, level) {
var i, j;
zip_deflate_data = str;
zip_deflate_pos = 0;
- if(typeof level == "undefined")
- level = zip_DEFAULT_LEVEL;
+ if (typeof level == "undefined") level = zip_DEFAULT_LEVEL;
zip_deflate_start(level);
var buff = new Array(1024);
var aout = [];
- while((i = zip_deflate_internal(buff, 0, buff.length)) > 0) {
- var cbuf = new Array(i);
- for(j = 0; j < i; j++){
- cbuf[j] = String.fromCharCode(buff[j]);
- }
- aout[aout.length] = cbuf.join("");
+ while ((i = zip_deflate_internal(buff, 0, buff.length)) > 0) {
+ var cbuf = new Array(i);
+ for (j = 0; j < i; j++) {
+ cbuf[j] = String.fromCharCode(buff[j]);
+ }
+ aout[aout.length] = cbuf.join("");
}
zip_deflate_data = null; // G.C.
return aout.join("");
-};
-
+ };
})();
module.exports = {
- deflate
-};
\ No newline at end of file
+ deflate,
+};
diff --git a/package.json b/package.json
index ad149d8..43fdc57 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
{
"name": "eleventy-plugin-plantuml",
- "version": "1.0.4",
+ "version": "1.0.5",
"description": "Eleventy (11ty) Plantuml markdown plugin",
"main": "index.js",
"repository": "git@github.com:awaragi/eleventy-plugin-plantuml.git",
@@ -21,12 +21,14 @@
"url": "https://github.com/awaragi/eleventy-plugin-plantuml/issues"
},
"scripts": {
- "test": "jest test"
+ "test": "jest test",
+ "format": "prettier --check ./**/* --write"
},
"dependencies": {
"sync-request": "^6.1.0"
},
"devDependencies": {
- "jest": "^27.0.5"
+ "jest": "^27.0.5",
+ "prettier": "^2.3.2"
}
}
diff --git a/test/eleventy-plugin-plantuml.test.js b/test/eleventy-plugin-plantuml.test.js
index 059e8fd..c182a2b 100644
--- a/test/eleventy-plugin-plantuml.test.js
+++ b/test/eleventy-plugin-plantuml.test.js
@@ -1,14 +1,20 @@
-const eleventyPluginPlantuml = require('../index');
-describe('Eleventy PlantUML Test Suite', () => {
- it('Testing a e2e basic conversion', () => {
- const img = eleventyPluginPlantuml.highlight(`@startuml
+const eleventyPluginPlantuml = require("../index");
+describe("Eleventy PlantUML Test Suite", () => {
+ it("Testing a e2e basic conversion", () => {
+ const img = eleventyPluginPlantuml.highlight(
+ `@startuml
Bob -> Alice : hello
-@enduml`, eleventyPluginPlantuml.defaultOptions);
- expect(img).toBe('
');
- });
+@enduml`,
+ eleventyPluginPlantuml.defaultOptions
+ );
+ expect(img).toBe(
+ ''
+ );
+ });
- it('Testing a e2e large conversion', () => {
- const img = eleventyPluginPlantuml.highlight(`@startuml
+ it("Testing a e2e large conversion", () => {
+ const img = eleventyPluginPlantuml.highlight(
+ `@startuml
!include https://raw.githubusercontent.com/bschwarz/puml-themes/master/themes/bluegray/puml-theme-bluegray.puml
participant "Makrdown Highlighter" as MDH
participant "eleventy-plugin-plantumt" as plugin
@@ -20,25 +26,31 @@ plugin -> plantuml: GET /png/{url}
plantuml -> plugin: image/png
plugin -> plugin: base64
plugin -> MDH: img src="dataurl"
-@enduml`, eleventyPluginPlantuml.defaultOptions);
- expect(img).toBe('
')
- });
+@enduml`,
+ eleventyPluginPlantuml.defaultOptions
+ );
+ expect(img).toBe(
+ ''
+ );
+ });
- it('Testing url generation', () => {
- const url = eleventyPluginPlantuml.generatePlantumlUrl('ABC', {
- protocol: 'https',
- hostname: 'localhost',
- port: "8080",
- prefix: "/path",
- outputType: "png",
- });
- expect(url).toBe('https://localhost:8080/path/png/ABC')
+ it("Testing url generation", () => {
+ const url = eleventyPluginPlantuml.generatePlantumlUrl("ABC", {
+ protocol: "https",
+ hostname: "localhost",
+ port: "8080",
+ prefix: "/path",
+ outputType: "png",
});
+ expect(url).toBe("https://localhost:8080/path/png/ABC");
+ });
- it('Testing img tag generation', () => {
- const tag = eleventyPluginPlantuml.generateImgTag('ABC', {
- imgClass: "plantuml"
- });
- expect(tag).toBe('
');
+ it("Testing img tag generation", () => {
+ const tag = eleventyPluginPlantuml.generateImgTag("ABC", {
+ imgClass: "plantuml",
});
-});
\ No newline at end of file
+ expect(tag).toBe(
+ ''
+ );
+ });
+});