package/package.json000644 001750 000144 0000001243 12141272674013021 0ustar00000000 000000 { "author": "Masanao Izumo ", "contributors": [ "T. Jameson Little ", "Dan Kogai " ], "name": "deflate-js", "description": "DEFLATE implemented in JavaScript (works in browser and Node)", "license": "GPL", "version": "0.2.3", "main": "./index.js", "bin": { "deflate-js": "./bin/deflate.js", "inflate-js": "./bin/inflate.js" }, "repository": { "type": "git", "url": "git://github.com/beatgammit/deflate-js.git" }, "scripts": { "test": "cd test ; ./runner.py; cd -" }, "engines": { "node": ">= 0.4.0" }, "dependencies": {}, "devDependencies": { "optimist": "~0.2" } } package/.npmignore000644 001750 000144 0000000077 12141270400012517 0ustar00000000 000000 node_modules pakmanaged* checks.json test-outs *.pyc *.deflate package/README.md000644 001750 000144 0000002203 12141272170011776 0ustar00000000 000000 Intro ===== Does deflate compression/decompression in the browser and node. This module is not meant to be run on node for any production code. The native version of deflate should be used instead because it is much faster. The main reason for this being node-compatible is for testing purposes. Currently deflate does not pass all tests, but inflate does. This should not be used for compressing data yet in production. Install ======= For node, deflate-js can be installed with npm: `npm install deflate-js` For the browser, deflate-js can be installed with pakmanager. API === Deflate: > *deflate(arr[, level])* > > **arr**- Byte array to compress > > **level**- 1-9 (compression level; optional) Inflate: > *inflate(arr)* > > > **arr**- Byte array to decompress The basic usage (no level) will suffice for most purposes. Basic Usage ----------- var deflate = require('deflate-js'), arr; arr = Array.prototype.map.call('Hello world', function (char) { return char.charCodeAt(0); }); // compress some text var compressed = deflate.deflate(arr); // decompress some text var decompressed = deflate.inflate(compressed); package/LICENSE000644 001750 000144 0000000521 12141272330011523 0ustar00000000 000000 All code in lib is licensed under the GPLv2. All other code (examples, test, etc) is licensed under the MIT license. Because of the nature of the GPL, this entire project is effectively under the GPLv2, except for the testing code, which is completely autonomous. For questions, please contact T. Jameson Little package/index.js000644 001750 000144 0000000226 12141270400012161 0ustar00000000 000000 (function () { 'use strict'; module.exports = { 'inflate': require('./lib/rawinflate.js'), 'deflate': require('./lib/rawdeflate.js') }; }()); package/LICENSE.GPLv2000644 001750 000144 0000043254 12141270440012426 0ustar00000000 000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. package/examples/package.json000644 001750 000144 0000000250 12141270400014615 0ustar00000000 000000 { "author": "T. Jameson Little", "name": "test", "version": "0.1.0", "main": "./main.js", "repository": {}, "engines": {}, "dependencies": { "jeesh": "*" } } package/examples/main.js000644 001750 000144 0000001731 12141270400013616 0ustar00000000 000000 (function () { 'use strict'; var inflate = require('../lib/rawinflate.js'), deflate = require('../lib/rawdeflate.js'), ender = require('ender'); ender.domReady(function () { ender('#inflated').bind('keyup', function () { var self = this, dst = ender('#deflated'); setTimeout(function(){ var arr, str; arr = Array.prototype.map.call(self.value, function (char) { return char.charCodeAt(0); }); str = deflate(arr).map(function (byte) { return String.fromCharCode(byte); }).join(''); dst.val(btoa(str)); },0); }); ender('#deflated').bind('keyup', function () { var self = this, dst = ender('#inflated'); setTimeout(function(){ var str, arr; arr = Array.prototype.map.call(atob(self.value), function (char) { return char.charCodeAt(0); }); str = inflate(arr).map(function (byte) { return String.fromCharCode(byte); }).join(''); dst.val(str); }, 0); }); }); }()); package/examples/index.html000644 001750 000144 0000001100 12141270400014317 0ustar00000000 000000 Test

DEFLATE Test Page

Enter text into the first text box to encode it, or enter base64 encoded deflate-encoded text into the second to decode

Inflated + Base64-Decoded (Original Text):
Deflated + Base64-Encoded (Compressed Output):
package/LICENSE.MIT000644 001750 000144 0000002074 12141270662012166 0ustar00000000 000000 The MIT License (MIT) Copyright (c) 2013 T. Jameson Little Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. package/lib/rawdeflate.js000644 001750 000144 0000141513 12141270400013743 0ustar00000000 000000 /* * $Id: rawdeflate.js,v 0.3 2009/03/01 19:05:05 dankogai Exp dankogai $ * * Original: * http://www.onicos.com/staff/iz/amuse/javascript/expert/deflate.txt */ /* Copyright (C) 1999 Masanao Izumo * Version: 1.0.1 * LastModified: Dec 25 1999 */ /* Interface: * data = deflate(src); */ (function () { /* constant parameters */ var WSIZE = 32768, // Sliding Window size STORED_BLOCK = 0, STATIC_TREES = 1, DYN_TREES = 2, /* for deflate */ DEFAULT_LEVEL = 6, FULL_SEARCH = false, INBUFSIZ = 32768, // Input buffer size //INBUF_EXTRA = 64, // Extra buffer OUTBUFSIZ = 1024 * 8, window_size = 2 * WSIZE, MIN_MATCH = 3, MAX_MATCH = 258, BITS = 16, // for SMALL_MEM LIT_BUFSIZE = 0x2000, // HASH_BITS = 13, //for MEDIUM_MEM // LIT_BUFSIZE = 0x4000, // HASH_BITS = 14, // for BIG_MEM // LIT_BUFSIZE = 0x8000, HASH_BITS = 15, DIST_BUFSIZE = LIT_BUFSIZE, HASH_SIZE = 1 << HASH_BITS, HASH_MASK = HASH_SIZE - 1, WMASK = WSIZE - 1, NIL = 0, // Tail of hash chains TOO_FAR = 4096, MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1, MAX_DIST = WSIZE - MIN_LOOKAHEAD, SMALLEST = 1, MAX_BITS = 15, MAX_BL_BITS = 7, LENGTH_CODES = 29, LITERALS = 256, END_BLOCK = 256, L_CODES = LITERALS + 1 + LENGTH_CODES, D_CODES = 30, BL_CODES = 19, REP_3_6 = 16, REPZ_3_10 = 17, REPZ_11_138 = 18, HEAP_SIZE = 2 * L_CODES + 1, H_SHIFT = parseInt((HASH_BITS + MIN_MATCH - 1) / MIN_MATCH, 10), /* variables */ free_queue, qhead, qtail, initflag, outbuf = null, outcnt, outoff, complete, window, d_buf, l_buf, prev, bi_buf, bi_valid, block_start, ins_h, hash_head, prev_match, match_available, match_length, prev_length, strstart, match_start, eofile, lookahead, max_chain_length, max_lazy_match, compr_level, good_match, nice_match, dyn_ltree, dyn_dtree, static_ltree, static_dtree, bl_tree, l_desc, d_desc, bl_desc, bl_count, heap, heap_len, heap_max, depth, length_code, dist_code, base_length, base_dist, flag_buf, last_lit, last_dist, last_flags, flags, flag_bit, opt_len, static_len, deflate_data, deflate_pos; if (LIT_BUFSIZE > INBUFSIZ) { console.error("error: INBUFSIZ is too small"); } if ((WSIZE << 1) > (1 << BITS)) { console.error("error: WSIZE is too large"); } if (HASH_BITS > BITS - 1) { console.error("error: HASH_BITS is too large"); } if (HASH_BITS < 8 || MAX_MATCH !== 258) { console.error("error: Code too clever"); } /* objects (deflate) */ function DeflateCT() { this.fc = 0; // frequency count or bit string this.dl = 0; // father node in Huffman tree or length of bit string } function 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 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.nice_length = c; // quit search above this match length this.max_chain = d; } function DeflateBuffer() { this.next = null; this.len = 0; this.ptr = []; // new Array(OUTBUFSIZ); // ptr.length is never read this.off = 0; } /* constant tables */ var 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 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 extra_blbits = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7]; var bl_order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]; var configuration_table = [ new DeflateConfiguration(0, 0, 0, 0), new DeflateConfiguration(4, 4, 8, 4), new DeflateConfiguration(4, 5, 16, 8), new DeflateConfiguration(4, 6, 32, 32), new DeflateConfiguration(4, 4, 16, 16), new DeflateConfiguration(8, 16, 32, 32), new DeflateConfiguration(8, 16, 128, 128), new DeflateConfiguration(8, 32, 128, 256), new DeflateConfiguration(32, 128, 258, 1024), new DeflateConfiguration(32, 258, 258, 4096) ]; /* routines (deflate) */ function deflate_start(level) { var i; if (!level) { level = DEFAULT_LEVEL; } else if (level < 1) { level = 1; } else if (level > 9) { level = 9; } compr_level = level; initflag = false; eofile = false; if (outbuf !== null) { return; } free_queue = qhead = qtail = null; outbuf = []; // new Array(OUTBUFSIZ); // outbuf.length never called window = []; // new Array(window_size); // window.length never called d_buf = []; // new Array(DIST_BUFSIZE); // d_buf.length never called l_buf = []; // new Array(INBUFSIZ + INBUF_EXTRA); // l_buf.length never called prev = []; // new Array(1 << BITS); // prev.length never called dyn_ltree = []; for (i = 0; i < HEAP_SIZE; i++) { dyn_ltree[i] = new DeflateCT(); } dyn_dtree = []; for (i = 0; i < 2 * D_CODES + 1; i++) { dyn_dtree[i] = new DeflateCT(); } static_ltree = []; for (i = 0; i < L_CODES + 2; i++) { static_ltree[i] = new DeflateCT(); } static_dtree = []; for (i = 0; i < D_CODES; i++) { static_dtree[i] = new DeflateCT(); } bl_tree = []; for (i = 0; i < 2 * BL_CODES + 1; i++) { bl_tree[i] = new DeflateCT(); } l_desc = new DeflateTreeDesc(); d_desc = new DeflateTreeDesc(); bl_desc = new DeflateTreeDesc(); bl_count = []; // new Array(MAX_BITS+1); // bl_count.length never called heap = []; // new Array(2*L_CODES+1); // heap.length never called depth = []; // new Array(2*L_CODES+1); // depth.length never called length_code = []; // new Array(MAX_MATCH-MIN_MATCH+1); // length_code.length never called dist_code = []; // new Array(512); // dist_code.length never called base_length = []; // new Array(LENGTH_CODES); // base_length.length never called base_dist = []; // new Array(D_CODES); // base_dist.length never called flag_buf = []; // new Array(parseInt(LIT_BUFSIZE / 8, 10)); // flag_buf.length never called } function deflate_end() { free_queue = qhead = qtail = null; outbuf = null; window = null; d_buf = null; l_buf = null; prev = null; dyn_ltree = null; dyn_dtree = null; static_ltree = null; static_dtree = null; bl_tree = null; l_desc = null; d_desc = null; bl_desc = null; bl_count = null; heap = null; depth = null; length_code = null; dist_code = null; base_length = null; base_dist = null; flag_buf = null; } function reuse_queue(p) { p.next = free_queue; free_queue = p; } function new_queue() { var p; if (free_queue !== null) { p = free_queue; free_queue = free_queue.next; } else { p = new DeflateBuffer(); } p.next = null; p.len = p.off = 0; return p; } function head1(i) { return prev[WSIZE + i]; } function head2(i, val) { return (prev[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 put_byte(c) { outbuf[outoff + outcnt++] = c; if (outoff + outcnt === OUTBUFSIZ) { qoutbuf(); } } /* Output a 16 bit value, lsb first */ function put_short(w) { w &= 0xffff; if (outoff + outcnt < OUTBUFSIZ - 2) { outbuf[outoff + outcnt++] = (w & 0xff); outbuf[outoff + outcnt++] = (w >>> 8); } else { put_byte(w & 0xff); 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 INSERT_STRING() { ins_h = ((ins_h << H_SHIFT) ^ (window[strstart + MIN_MATCH - 1] & 0xff)) & HASH_MASK; hash_head = head1(ins_h); prev[strstart & WMASK] = hash_head; head2(ins_h, strstart); } /* Send a code of the given tree. c and tree must not have side effects */ function SEND_CODE(c, tree) { 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 D_CODE(dist) { return (dist < 256 ? dist_code[dist] : 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 SMALLER(tree, n, m) { return tree[n].fc < tree[m].fc || (tree[n].fc === tree[m].fc && depth[n] <= depth[m]); } /* ========================================================================== * read string data */ function read_buff(buff, offset, n) { var i; for (i = 0; i < n && deflate_pos < deflate_data.length; i++) { buff[offset + i] = deflate_data[deflate_pos++] & 0xff; } return i; } /* ========================================================================== * Initialize the "longest match" routines for a new file */ function lm_init() { var j; // Initialize the hash table. */ for (j = 0; j < HASH_SIZE; j++) { // head2(j, NIL); prev[WSIZE + j] = 0; } // prev will be initialized on the fly */ // Set the default configuration parameters: max_lazy_match = configuration_table[compr_level].max_lazy; good_match = configuration_table[compr_level].good_length; if (!FULL_SEARCH) { nice_match = configuration_table[compr_level].nice_length; } max_chain_length = configuration_table[compr_level].max_chain; strstart = 0; block_start = 0; lookahead = read_buff(window, 0, 2 * WSIZE); if (lookahead <= 0) { eofile = true; lookahead = 0; return; } eofile = false; // Make sure that we always have enough lookahead. This is important // if input comes from a device such as a tty. while (lookahead < MIN_LOOKAHEAD && !eofile) { fill_window(); } // If lookahead < MIN_MATCH, ins_h is garbage, but this is // not important since only literal bytes will be emitted. ins_h = 0; for (j = 0; j < MIN_MATCH - 1; j++) { // UPDATE_HASH(ins_h, window[j]); ins_h = ((ins_h << H_SHIFT) ^ (window[j] & 0xff)) & 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 longest_match(cur_match) { var chain_length = max_chain_length; // max hash chain length var scanp = strstart; // current string var matchp; // matched string var len; // length of current match var best_len = 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 = (strstart > MAX_DIST ? strstart - MAX_DIST : NIL); var strendp = strstart + MAX_MATCH; var scan_end1 = window[scanp + best_len - 1]; var scan_end = window[scanp + best_len]; var i, broke; // Do not waste too much time if we already have a good match: */ if (prev_length >= good_match) { chain_length >>= 2; } // 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 (window[matchp + best_len] !== scan_end || window[matchp + best_len - 1] !== scan_end1 || window[matchp] !== window[scanp] || window[++matchp] !== 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++; // We check for insufficient lookahead only every 8th comparison; // the 256th check will be made at strstart+258. while (scanp < strendp) { broke = false; for (i = 0; i < 8; i += 1) { scanp += 1; matchp += 1; if (window[scanp] !== window[matchp]) { broke = true; break; } } if (broke) { break; } } len = MAX_MATCH - (strendp - scanp); scanp = strendp - MAX_MATCH; if (len > best_len) { match_start = cur_match; best_len = len; if (FULL_SEARCH) { if (len >= MAX_MATCH) { break; } } else { if (len >= nice_match) { break; } } scan_end1 = window[scanp + best_len - 1]; scan_end = window[scanp + best_len]; } } while ((cur_match = prev[cur_match & 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 fill_window() { var n, m; // Amount of free space at the end of the window. var more = window_size - lookahead - strstart; // 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 (strstart >= WSIZE + 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 < WSIZE; n++) { window[n] = window[n + WSIZE]; } match_start -= WSIZE; strstart -= WSIZE; /* we now have strstart >= MAX_DIST: */ block_start -= WSIZE; for (n = 0; n < HASH_SIZE; n++) { m = head1(n); head2(n, m >= WSIZE ? m - WSIZE : NIL); } for (n = 0; n < WSIZE; n++) { // If n is not on any hash chain, prev[n] is garbage but // its value will never be used. m = prev[n]; prev[n] = (m >= WSIZE ? m - WSIZE : NIL); } more += WSIZE; } // At this point, more >= 2 if (!eofile) { n = read_buff(window, strstart + lookahead, more); if (n <= 0) { eofile = true; } else { 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 deflate_fast() { while (lookahead !== 0 && 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: INSERT_STRING(); // Find the longest match, discarding those <= prev_length. // At this point we have always match_length < MIN_MATCH if (hash_head !== NIL && strstart - hash_head <= 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). match_length = longest_match(hash_head); // longest_match() sets match_start */ if (match_length > lookahead) { match_length = lookahead; } } if (match_length >= MIN_MATCH) { // check_match(strstart, match_start, match_length); flush = ct_tally(strstart - match_start, match_length - MIN_MATCH); lookahead -= 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 (match_length <= max_lazy_match) { match_length--; // string at strstart already in hash table do { strstart++; 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 (--match_length !== 0); strstart++; } else { strstart += match_length; match_length = 0; ins_h = window[strstart] & 0xff; // UPDATE_HASH(ins_h, window[strstart + 1]); ins_h = ((ins_h << H_SHIFT) ^ (window[strstart + 1] & 0xff)) & HASH_MASK; //#if MIN_MATCH !== 3 // Call UPDATE_HASH() MIN_MATCH-3 more times //#endif } } else { // No match, output a literal byte */ flush = ct_tally(0, window[strstart] & 0xff); lookahead--; strstart++; } if (flush) { flush_block(0); block_start = 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 (lookahead < MIN_LOOKAHEAD && !eofile) { fill_window(); } } } function deflate_better() { // Process the input block. */ while (lookahead !== 0 && qhead === null) { // Insert the string window[strstart .. strstart+2] in the // dictionary, and set hash_head to the head of the hash chain: INSERT_STRING(); // Find the longest match, discarding those <= prev_length. prev_length = match_length; prev_match = match_start; match_length = MIN_MATCH - 1; if (hash_head !== NIL && prev_length < max_lazy_match && strstart - hash_head <= 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). match_length = longest_match(hash_head); // longest_match() sets match_start */ if (match_length > lookahead) { match_length = lookahead; } // Ignore a length 3 match if it is too distant: */ if (match_length === MIN_MATCH && strstart - match_start > TOO_FAR) { // If prev_match is also MIN_MATCH, match_start is garbage // but we will ignore the current match anyway. match_length--; } } // If there was a match at the previous step and the current // match is not better, output the previous match: if (prev_length >= MIN_MATCH && match_length <= prev_length) { var flush; // set if current block must be flushed // check_match(strstart - 1, prev_match, prev_length); flush = ct_tally(strstart - 1 - prev_match, prev_length - MIN_MATCH); // Insert in hash table all strings up to the end of the match. // strstart-1 and strstart are already inserted. lookahead -= prev_length - 1; prev_length -= 2; do { strstart++; 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 (--prev_length !== 0); match_available = false; match_length = MIN_MATCH - 1; strstart++; if (flush) { flush_block(0); block_start = strstart; } } else if (match_available) { // 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 (ct_tally(0, window[strstart - 1] & 0xff)) { flush_block(0); block_start = strstart; } strstart++; lookahead--; } else { // There is no previous match to compare with, wait for // the next step to decide. match_available = true; strstart++; 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 (lookahead < MIN_LOOKAHEAD && !eofile) { fill_window(); } } } function init_deflate() { if (eofile) { return; } bi_buf = 0; bi_valid = 0; ct_init(); lm_init(); qhead = null; outcnt = 0; outoff = 0; if (compr_level <= 3) { prev_length = MIN_MATCH - 1; match_length = 0; } else { match_length = MIN_MATCH - 1; match_available = false; } 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 deflate_internal(buff, off, buff_size) { var n; if (!initflag) { init_deflate(); initflag = true; if (lookahead === 0) { // empty complete = true; return 0; } } n = qcopy(buff, off, buff_size); if (n === buff_size) { return buff_size; } if (complete) { return n; } if (compr_level <= 3) { // optimized for speed deflate_fast(); } else { deflate_better(); } if (lookahead === 0) { if (match_available) { ct_tally(0, window[strstart - 1] & 0xff); } flush_block(1); complete = true; } return n + qcopy(buff, n + off, buff_size - n); } function qcopy(buff, off, buff_size) { var n, i, j; n = 0; while (qhead !== null && n < buff_size) { i = buff_size - n; if (i > qhead.len) { i = qhead.len; } // System.arraycopy(qhead.ptr, qhead.off, buff, off + n, i); for (j = 0; j < i; j++) { buff[off + n + j] = qhead.ptr[qhead.off + j]; } qhead.off += i; qhead.len -= i; n += i; if (qhead.len === 0) { var p; p = qhead; qhead = qhead.next; reuse_queue(p); } } if (n === buff_size) { return n; } if (outoff < outcnt) { i = buff_size - n; if (i > outcnt - outoff) { i = outcnt - outoff; } // System.arraycopy(outbuf, outoff, buff, off + n, i); for (j = 0; j < i; j++) { buff[off + n + j] = outbuf[outoff + j]; } outoff += i; n += i; if (outcnt === outoff) { outcnt = 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 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 (static_dtree[0].dl !== 0) { return; // ct_init already called } l_desc.dyn_tree = dyn_ltree; l_desc.static_tree = static_ltree; l_desc.extra_bits = extra_lbits; l_desc.extra_base = LITERALS + 1; l_desc.elems = L_CODES; l_desc.max_length = MAX_BITS; l_desc.max_code = 0; d_desc.dyn_tree = dyn_dtree; d_desc.static_tree = static_dtree; d_desc.extra_bits = extra_dbits; d_desc.extra_base = 0; d_desc.elems = D_CODES; d_desc.max_length = MAX_BITS; d_desc.max_code = 0; bl_desc.dyn_tree = bl_tree; bl_desc.static_tree = null; bl_desc.extra_bits = extra_blbits; bl_desc.extra_base = 0; bl_desc.elems = BL_CODES; bl_desc.max_length = MAX_BL_BITS; bl_desc.max_code = 0; // Initialize the mapping length (0..255) -> length code (0..28) length = 0; for (code = 0; code < LENGTH_CODES - 1; code++) { base_length[code] = length; for (n = 0; n < (1 << extra_lbits[code]); n++) { length_code[length++] = code; } } // Assert (length === 256, "ct_init: length !== 256"); // Note that the length 255 (match length 258) can be represented // in two different ways: code 284 + 5 bits or code 285, so we // overwrite length_code[255] to use the best encoding: length_code[length - 1] = code; // Initialize the mapping dist (0..32K) -> dist code (0..29) */ dist = 0; for (code = 0; code < 16; code++) { base_dist[code] = dist; for (n = 0; n < (1 << extra_dbits[code]); n++) { dist_code[dist++] = code; } } // Assert (dist === 256, "ct_init: dist !== 256"); // from now on, all distances are divided by 128 for (dist >>= 7; code < D_CODES; code++) { base_dist[code] = dist << 7; for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) { 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 <= MAX_BITS; bits++) { bl_count[bits] = 0; } n = 0; while (n <= 143) { static_ltree[n++].dl = 8; bl_count[8]++; } while (n <= 255) { static_ltree[n++].dl = 9; bl_count[9]++; } while (n <= 279) { static_ltree[n++].dl = 7; bl_count[7]++; } while (n <= 287) { static_ltree[n++].dl = 8; 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) gen_codes(static_ltree, L_CODES + 1); // The static distance tree is trivial: */ for (n = 0; n < D_CODES; n++) { static_dtree[n].dl = 5; static_dtree[n].fc = bi_reverse(n, 5); } // Initialize the first block of the first file: init_block(); } /* ========================================================================== * Initialize a new block. */ function init_block() { var n; // iterates over tree elements // Initialize the trees. for (n = 0; n < L_CODES; n++) { dyn_ltree[n].fc = 0; } for (n = 0; n < D_CODES; n++) { dyn_dtree[n].fc = 0; } for (n = 0; n < BL_CODES; n++) { bl_tree[n].fc = 0; } dyn_ltree[END_BLOCK].fc = 1; opt_len = static_len = 0; last_lit = last_dist = last_flags = 0; flags = 0; 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). * * @param tree- tree to restore * @param k- node to move down */ function pqdownheap(tree, k) { var v = heap[k], j = k << 1; // left son of k while (j <= heap_len) { // Set j to the smallest of the two sons: if (j < heap_len && SMALLER(tree, heap[j + 1], heap[j])) { j++; } // Exit if v is smaller than both sons if (SMALLER(tree, v, heap[j])) { break; } // Exchange v with the smallest son heap[k] = heap[j]; k = j; // And continue down the tree, setting j to the left son of k j <<= 1; } 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 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 <= MAX_BITS; bits++) { 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[heap[heap_max]].dl = 0; // root of the heap for (h = heap_max + 1; h < HEAP_SIZE; h++) { n = 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 } bl_count[bits]++; xbits = 0; if (n >= base) { xbits = extra[n - base]; } f = tree[n].fc; opt_len += f * (bits + xbits); if (stree !== null) { static_len += f * (stree[n].dl + xbits); } } 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 (bl_count[bits] === 0) { bits--; } bl_count[bits]--; // move one leaf down the tree bl_count[bits + 1] += 2; // move one overflow item as its brother 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 = bl_count[bits]; while (n !== 0) { m = heap[--h]; if (m > max_code) { continue; } if (tree[m].dl !== bits) { 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 * optimal). * IN assertion: the array bl_count contains the bit length statistics for * the given tree and the field len is set for all tree elements. * OUT assertion: the field code is set for all tree elements of non * zero code length. * @param tree- the tree to decorate * @param max_code- largest code with non-zero frequency */ function gen_codes(tree, max_code) { var next_code = []; // new Array(MAX_BITS + 1); // next code value for each bit length var code = 0; // running code value var bits; // bit index var n; // code index // The distribution counts are first used to generate the code values // without bit reversal. for (bits = 1; bits <= MAX_BITS; bits++) { code = ((code + 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<> 1; n >= 1; n--) { pqdownheap(tree, n); } // Construct the Huffman tree by repeatedly combining the least two // frequent nodes. do { n = heap[SMALLEST]; heap[SMALLEST] = heap[heap_len--]; pqdownheap(tree, SMALLEST); m = heap[SMALLEST]; // m = node of next least frequency // keep the nodes sorted by frequency heap[--heap_max] = n; heap[--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 (depth[n] > depth[m] + 1) { depth[node] = depth[n]; } else { depth[node] = depth[m] + 1; } tree[n].dl = tree[m].dl = node; // and insert the new node in the heap heap[SMALLEST] = node++; pqdownheap(tree, SMALLEST); } while (heap_len >= 2); heap[--heap_max] = heap[SMALLEST]; // At this point, the fields freq and dad are set. We can now // generate the bit lengths. gen_bitlen(desc); // The field len is now set, we can generate the bit codes 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.) * * @param tree- the tree to be scanned * @param max_code- and its largest code of non zero frequency */ function scan_tree(tree, max_code) { var n, // iterates over all tree elements prevlen = -1, // last emitted length curlen, // length of current code nextlen = tree[0].dl, // length of next code count = 0, // repeat count of the current code max_count = 7, // max repeat count 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) { bl_tree[curlen].fc += count; } else if (curlen !== 0) { if (curlen !== prevlen) { bl_tree[curlen].fc++; } bl_tree[REP_3_6].fc++; } else if (count <= 10) { bl_tree[REPZ_3_10].fc++; } else { bl_tree[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. * * @param tree- the tree to be scanned * @param max_code- and its largest code of non zero frequency */ function send_tree(tree, max_code) { 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 { SEND_CODE(curlen, bl_tree); } while (--count !== 0); } else if (curlen !== 0) { if (curlen !== prevlen) { SEND_CODE(curlen, bl_tree); count--; } // Assert(count >= 3 && count <= 6, " 3_6?"); SEND_CODE(REP_3_6, bl_tree); send_bits(count - 3, 2); } else if (count <= 10) { SEND_CODE(REPZ_3_10, bl_tree); send_bits(count - 3, 3); } else { SEND_CODE(REPZ_11_138, bl_tree); 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 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 scan_tree(dyn_ltree, l_desc.max_code); scan_tree(dyn_dtree, d_desc.max_code); // Build the bit length tree: build_tree(bl_desc); // opt_len now includes the length of the tree representations, except // the lengths of the bit lengths codes and the 5+5+4 bits for the counts. // Determine the number of bit length codes to send. The pkzip format // requires that at least 4 bit length codes be sent. (appnote.txt says // 3 but the actual value used is 4.) for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) { if (bl_tree[bl_order[max_blindex]].dl !== 0) { break; } } // Update opt_len to include the bit length tree and counts */ 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 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: ")); send_bits(lcodes - 257, 5); // not +255 as stated in appnote.txt send_bits(dcodes - 1, 5); 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])); send_bits(bl_tree[bl_order[rank]].dl, 3); } // send the literal tree send_tree(dyn_ltree, lcodes - 1); // send the distance tree send_tree(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 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 max_blindex, // index of last bit length code of non zero freq stored_len, // length of input block i; stored_len = strstart - block_start; flag_buf[last_flags] = flags; // Save the flags for the last 8 items // Construct the literal and distance trees build_tree(l_desc); // Tracev((stderr, "\nlit data: dyn %ld, stat %ld", // encoder->opt_len, encoder->static_len)); build_tree(d_desc); // 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. // Build the bit length tree for the above two trees, and get the index // in bl_order of the last bit length code to send. max_blindex = build_bl_tree(); // Determine the best encoding. Compute first the block length in bytes opt_lenb = (opt_len + 3 + 7) >> 3; static_lenb = (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 && block_start >= 0) { // 4: two words for the lengths // 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. send_bits((STORED_BLOCK << 1) + eof, 3); /* send block type */ bi_windup(); /* align on byte boundary */ put_short(stored_len); 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++) { put_byte(window[block_start + i]); } } else if (static_lenb === opt_lenb) { send_bits((STATIC_TREES << 1) + eof, 3); compress_block(static_ltree, static_dtree); } else { send_bits((DYN_TREES << 1) + eof, 3); send_all_trees(l_desc.max_code + 1, d_desc.max_code + 1, max_blindex + 1); compress_block(dyn_ltree, dyn_dtree); } init_block(); if (eof !== 0) { bi_windup(); } } /* ========================================================================== * Save the match info and tally the frequency counts. Return true if * the current block must be flushed. * * @param dist- distance of matched string * @param lc- (match length - MIN_MATCH) or unmatched char (if dist === 0) */ function ct_tally(dist, lc) { l_buf[last_lit++] = lc; if (dist === 0) { // lc is the unmatched char 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"); dyn_ltree[length_code[lc] + LITERALS + 1].fc++; dyn_dtree[D_CODE(dist)].fc++; d_buf[last_dist++] = dist; flags |= flag_bit; } flag_bit <<= 1; // Output the flags if they fill a byte if ((last_lit & 7) === 0) { flag_buf[last_flags++] = flags; flags = 0; flag_bit = 1; } // Try to guess if it is profitable to stop the current block here if (compr_level > 2 && (last_lit & 0xfff) === 0) { // Compute an upper bound for the compressed length var out_length = last_lit * 8; var in_length = strstart - block_start; var dcode; for (dcode = 0; dcode < D_CODES; dcode++) { out_length += dyn_dtree[dcode].fc * (5 + 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 (last_dist < parseInt(last_lit / 2, 10) && out_length < parseInt(in_length / 2, 10)) { return true; } } return (last_lit === LIT_BUFSIZE - 1 || last_dist === 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 * * @param ltree- literal tree * @param dtree- distance tree */ function compress_block(ltree, dtree) { 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 (last_lit !== 0) { do { if ((lx & 7) === 0) { flag = flag_buf[fx++]; } lc = l_buf[lx++] & 0xff; if ((flag & 1) === 0) { SEND_CODE(lc, ltree); /* send a literal byte */ // Tracecv(isgraph(lc), (stderr," '%c' ", lc)); } else { // Here, lc is the match length - MIN_MATCH code = length_code[lc]; SEND_CODE(code + LITERALS + 1, ltree); // send the length code extra = extra_lbits[code]; if (extra !== 0) { lc -= base_length[code]; send_bits(lc, extra); // send the extra length bits } dist = d_buf[dx++]; // Here, dist is the match distance - 1 code = D_CODE(dist); // Assert (code < D_CODES, "bad d_code"); SEND_CODE(code, dtree); // send the distance code extra = extra_dbits[code]; if (extra !== 0) { dist -= base_dist[code]; send_bits(dist, extra); // send the extra distance bits } } // literal or match pair ? flag >>= 1; } while (lx < last_lit); } SEND_CODE(END_BLOCK, ltree); } /* ========================================================================== * Send a value on a given number of bits. * IN assertion: length <= 16 and value fits in length bits. * * @param value- value to send * @param length- number of bits */ var Buf_size = 16; // bit size of bi_buf function send_bits(value, length) { // 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 (bi_valid > Buf_size - length) { bi_buf |= (value << bi_valid); put_short(bi_buf); bi_buf = (value >> (Buf_size - bi_valid)); bi_valid += length - Buf_size; } else { bi_buf |= value << bi_valid; 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 * * @param code- the value to invert * @param len- its bit length */ function bi_reverse(code, len) { var res = 0; do { res |= code & 1; code >>= 1; res <<= 1; } while (--len > 0); return res >> 1; } /* ========================================================================== * Write out any remaining bits in an incomplete byte. */ function bi_windup() { if (bi_valid > 8) { put_short(bi_buf); } else if (bi_valid > 0) { put_byte(bi_buf); } bi_buf = 0; bi_valid = 0; } function qoutbuf() { var q, i; if (outcnt !== 0) { q = new_queue(); if (qhead === null) { qhead = qtail = q; } else { qtail = qtail.next = q; } q.len = outcnt - outoff; // System.arraycopy(outbuf, outoff, q.ptr, 0, q.len); for (i = 0; i < q.len; i++) { q.ptr[i] = outbuf[outoff + i]; } outcnt = outoff = 0; } } function deflate(arr, level) { var i, j, buff; deflate_data = arr; deflate_pos = 0; if (typeof level === "undefined") { level = DEFAULT_LEVEL; } deflate_start(level); buff = []; do { i = deflate_internal(buff, buff.length, 1024); } while (i > 0); deflate_data = null; // G.C. return buff; } module.exports = deflate; module.exports.DEFAULT_LEVEL = DEFAULT_LEVEL; }()); package/lib/rawinflate.js000644 001750 000144 0000044133 12141270400013761 0ustar00000000 000000 /* * $Id: rawinflate.js,v 0.2 2009/03/01 18:32:24 dankogai Exp $ * * original: * http://www.onicos.com/staff/iz/amuse/javascript/expert/inflate.txt */ /* Copyright (C) 1999 Masanao Izumo * Version: 1.0.0.1 * LastModified: Dec 25 1999 */ /* Interface: * data = inflate(src); */ (function () { /* constant parameters */ var WSIZE = 32768, // Sliding Window size STORED_BLOCK = 0, STATIC_TREES = 1, DYN_TREES = 2, /* for inflate */ lbits = 9, // bits in base literal/length lookup table dbits = 6, // bits in base distance lookup table /* variables (inflate) */ slide, wp, // current position in slide fixed_tl = null, // inflate static fixed_td, // inflate static fixed_bl, // inflate static fixed_bd, // inflate static bit_buf, // bit buffer bit_len, // bits in bit buffer method, eof, copy_leng, copy_dist, tl, // literal length decoder table td, // literal distance decoder table bl, // number of bits decoded by tl bd, // number of bits decoded by td inflate_data, inflate_pos, /* constant tables (inflate) */ MASK_BITS = [ 0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff, 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff ], // Tables for deflate from PKZIP's appnote.txt. // Copy lengths for literal codes 257..285 cplens = [ 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 ], /* note: see note #13 above about the 258 in this list. */ // Extra bits for literal codes 257..285 cplext = [ 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, 99, 99 // 99==invalid ], // Copy offsets for distance codes 0..29 cpdist = [ 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577 ], // Extra bits for distance codes cpdext = [ 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 ], // Order of the bit length code lengths border = [ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ]; /* objects (inflate) */ function HuftList() { this.next = null; this.list = null; } function HuftNode() { this.e = 0; // number of extra bits or operation this.b = 0; // number of bits in this code or subcode // union this.n = 0; // literal, length base, or distance base this.t = null; // (HuftNode) pointer to next level of table } /* * @param b- code lengths in bits (all assumed <= BMAX) * @param n- number of codes (assumed <= N_MAX) * @param s- number of simple-valued codes (0..s-1) * @param d- list of base values for non-simple codes * @param e- list of extra bits for non-simple codes * @param mm- maximum lookup bits */ function HuftBuild(b, n, s, d, e, mm) { this.BMAX = 16; // maximum bit length of any code this.N_MAX = 288; // maximum number of codes in any set this.status = 0; // 0: success, 1: incomplete table, 2: bad input this.root = null; // (HuftList) starting table this.m = 0; // maximum lookup bits, returns actual /* Given a list of code lengths and a maximum table size, make a set of tables to decode that set of codes. Return zero on success, one if the given code set is incomplete (the tables are still built in this case), two if the input is invalid (all zero length codes or an oversubscribed set of lengths), and three if not enough memory. The code with value 256 is special, and the tables are constructed so that no bits beyond that code are fetched when that code is decoded. */ var a; // counter for codes of length k var c = []; var el; // length of EOB code (value 256) var f; // i repeats in table every f entries var g; // maximum code length var h; // table level var i; // counter, current code var j; // counter var k; // number of bits in current code var lx = []; var p; // pointer into c[], b[], or v[] var pidx; // index of p var q; // (HuftNode) points to current table var r = new HuftNode(); // table entry for structure assignment var u = []; var v = []; var w; var x = []; var xp; // pointer into x or c var y; // number of dummy codes added var z; // number of entries in current table var o; var tail; // (HuftList) tail = this.root = null; // bit length count table for (i = 0; i < this.BMAX + 1; i++) { c[i] = 0; } // stack of bits per table for (i = 0; i < this.BMAX + 1; i++) { lx[i] = 0; } // HuftNode[BMAX][] table stack for (i = 0; i < this.BMAX; i++) { u[i] = null; } // values in order of bit length for (i = 0; i < this.N_MAX; i++) { v[i] = 0; } // bit offsets, then code stack for (i = 0; i < this.BMAX + 1; i++) { x[i] = 0; } // Generate counts for each bit length el = n > 256 ? b[256] : this.BMAX; // set length of EOB code, if any p = b; pidx = 0; i = n; do { c[p[pidx]]++; // assume all entries <= BMAX pidx++; } while (--i > 0); if (c[0] === n) { // null input--all zero length codes this.root = null; this.m = 0; this.status = 0; return; } // Find minimum and maximum length, bound *m by those for (j = 1; j <= this.BMAX; j++) { if (c[j] !== 0) { break; } } k = j; // minimum code length if (mm < j) { mm = j; } for (i = this.BMAX; i !== 0; i--) { if (c[i] !== 0) { break; } } g = i; // maximum code length if (mm > i) { mm = i; } // Adjust last length count to fill out codes, if needed for (y = 1 << j; j < i; j++, y <<= 1) { if ((y -= c[j]) < 0) { this.status = 2; // bad input: more codes than bits this.m = mm; return; } } if ((y -= c[i]) < 0) { this.status = 2; this.m = mm; return; } c[i] += y; // Generate starting offsets into the value table for each length x[1] = j = 0; p = c; pidx = 1; xp = 2; while (--i > 0) { // note that i == g from above x[xp++] = (j += p[pidx++]); } // Make a table of values in order of bit lengths p = b; pidx = 0; i = 0; do { if ((j = p[pidx++]) !== 0) { v[x[j]++] = i; } } while (++i < n); n = x[g]; // set n to length of v // Generate the Huffman codes and for each, make the table entries x[0] = i = 0; // first Huffman code is zero p = v; pidx = 0; // grab values in bit order h = -1; // no tables yet--level -1 w = lx[0] = 0; // no bits decoded yet q = null; // ditto z = 0; // ditto // go through the bit lengths (k already is bits in shortest code) for (null; k <= g; k++) { a = c[k]; while (a-- > 0) { // here i is the Huffman code of length k bits for value p[pidx] // make tables up to required level while (k > w + lx[1 + h]) { w += lx[1 + h]; // add bits already decoded h++; // compute minimum size table less than or equal to *m bits z = (z = g - w) > mm ? mm : z; // upper limit if ((f = 1 << (j = k - w)) > a + 1) { // try a k-w bit table // too few codes for k-w bit table f -= a + 1; // deduct codes from patterns left xp = k; while (++j < z) { // try smaller tables up to z bits if ((f <<= 1) <= c[++xp]) { break; // enough codes to use up j bits } f -= c[xp]; // else deduct codes from patterns } } if (w + j > el && w < el) { j = el - w; // make EOB code end at table } z = 1 << j; // table entries for j-bit table lx[1 + h] = j; // set table size in stack // allocate and link in new table q = []; for (o = 0; o < z; o++) { q[o] = new HuftNode(); } if (!tail) { tail = this.root = new HuftList(); } else { tail = tail.next = new HuftList(); } tail.next = null; tail.list = q; u[h] = q; // table starts after link /* connect to last table, if there is one */ if (h > 0) { x[h] = i; // save pattern for backing up r.b = lx[h]; // bits to dump before this table r.e = 16 + j; // bits in this table r.t = q; // pointer to this table j = (i & ((1 << w) - 1)) >> (w - lx[h]); u[h - 1][j].e = r.e; u[h - 1][j].b = r.b; u[h - 1][j].n = r.n; u[h - 1][j].t = r.t; } } // set up table entry in r r.b = k - w; if (pidx >= n) { r.e = 99; // out of values--invalid code } else if (p[pidx] < s) { r.e = (p[pidx] < 256 ? 16 : 15); // 256 is end-of-block code r.n = p[pidx++]; // simple code is just the value } else { r.e = e[p[pidx] - s]; // non-simple--look up in lists r.n = d[p[pidx++] - s]; } // fill code-like entries with r // f = 1 << (k - w); for (j = i >> w; j < z; j += f) { q[j].e = r.e; q[j].b = r.b; q[j].n = r.n; q[j].t = r.t; } // backwards increment the k-bit code i for (j = 1 << (k - 1); (i & j) !== 0; j >>= 1) { i ^= j; } i ^= j; // backup over finished tables while ((i & ((1 << w) - 1)) !== x[h]) { w -= lx[h]; // don't need to update q h--; } } } /* return actual size of base table */ this.m = lx[1]; /* Return true (1) if we were given an incomplete table */ this.status = ((y !== 0 && g !== 1) ? 1 : 0); } /* routines (inflate) */ function GET_BYTE() { if (inflate_data.length === inflate_pos) { return -1; } return inflate_data[inflate_pos++] & 0xff; } function NEEDBITS(n) { while (bit_len < n) { bit_buf |= GET_BYTE() << bit_len; bit_len += 8; } } function GETBITS(n) { return bit_buf & MASK_BITS[n]; } function DUMPBITS(n) { bit_buf >>= n; bit_len -= n; } function inflate_codes(buff, off, size) { // inflate (decompress) the codes in a deflated (compressed) block. // Return an error code or zero if it all goes ok. var e; // table entry flag/number of extra bits var t; // (HuftNode) pointer to table entry var n; if (size === 0) { return 0; } // inflate the coded data n = 0; for (;;) { // do until end of block NEEDBITS(bl); t = tl.list[GETBITS(bl)]; e = t.e; while (e > 16) { if (e === 99) { return -1; } DUMPBITS(t.b); e -= 16; NEEDBITS(e); t = t.t[GETBITS(e)]; e = t.e; } DUMPBITS(t.b); if (e === 16) { // then it's a literal wp &= WSIZE - 1; buff[off + n++] = slide[wp++] = t.n; if (n === size) { return size; } continue; } // exit if end of block if (e === 15) { break; } // it's an EOB or a length // get length of block to copy NEEDBITS(e); copy_leng = t.n + GETBITS(e); DUMPBITS(e); // decode distance of block to copy NEEDBITS(bd); t = td.list[GETBITS(bd)]; e = t.e; while (e > 16) { if (e === 99) { return -1; } DUMPBITS(t.b); e -= 16; NEEDBITS(e); t = t.t[GETBITS(e)]; e = t.e; } DUMPBITS(t.b); NEEDBITS(e); copy_dist = wp - t.n - GETBITS(e); DUMPBITS(e); // do the copy while (copy_leng > 0 && n < size) { copy_leng--; copy_dist &= WSIZE - 1; wp &= WSIZE - 1; buff[off + n++] = slide[wp++] = slide[copy_dist++]; } if (n === size) { return size; } } method = -1; // done return n; } function inflate_stored(buff, off, size) { /* "decompress" an inflated type 0 (stored) block. */ var n; // go to byte boundary n = bit_len & 7; DUMPBITS(n); // get the length and its complement NEEDBITS(16); n = GETBITS(16); DUMPBITS(16); NEEDBITS(16); if (n !== ((~bit_buf) & 0xffff)) { return -1; // error in compressed data } DUMPBITS(16); // read and output the compressed data copy_leng = n; n = 0; while (copy_leng > 0 && n < size) { copy_leng--; wp &= WSIZE - 1; NEEDBITS(8); buff[off + n++] = slide[wp++] = GETBITS(8); DUMPBITS(8); } if (copy_leng === 0) { method = -1; // done } return n; } function inflate_fixed(buff, off, size) { // decompress an inflated type 1 (fixed Huffman codes) block. We should // either replace this with a custom decoder, or at least precompute the // Huffman tables. // if first time, set up tables for fixed blocks if (!fixed_tl) { var i; // temporary variable var l = []; // 288 length list for huft_build (initialized below) var h; // HuftBuild // literal table for (i = 0; i < 144; i++) { l[i] = 8; } for (null; i < 256; i++) { l[i] = 9; } for (null; i < 280; i++) { l[i] = 7; } for (null; i < 288; i++) { // make a complete, but wrong code set l[i] = 8; } fixed_bl = 7; h = new HuftBuild(l, 288, 257, cplens, cplext, fixed_bl); if (h.status !== 0) { console.error("HufBuild error: " + h.status); return -1; } fixed_tl = h.root; fixed_bl = h.m; // distance table for (i = 0; i < 30; i++) { // make an incomplete code set l[i] = 5; } fixed_bd = 5; h = new HuftBuild(l, 30, 0, cpdist, cpdext, fixed_bd); if (h.status > 1) { fixed_tl = null; console.error("HufBuild error: " + h.status); return -1; } fixed_td = h.root; fixed_bd = h.m; } tl = fixed_tl; td = fixed_td; bl = fixed_bl; bd = fixed_bd; return inflate_codes(buff, off, size); } function inflate_dynamic(buff, off, size) { // decompress an inflated type 2 (dynamic Huffman codes) block. var i; // temporary variables var j; var l; // last length var n; // number of lengths to get var t; // (HuftNode) literal/length code table var nb; // number of bit length codes var nl; // number of literal/length codes var nd; // number of distance codes var ll = []; var h; // (HuftBuild) // literal/length and distance code lengths for (i = 0; i < 286 + 30; i++) { ll[i] = 0; } // read in table lengths NEEDBITS(5); nl = 257 + GETBITS(5); // number of literal/length codes DUMPBITS(5); NEEDBITS(5); nd = 1 + GETBITS(5); // number of distance codes DUMPBITS(5); NEEDBITS(4); nb = 4 + GETBITS(4); // number of bit length codes DUMPBITS(4); if (nl > 286 || nd > 30) { return -1; // bad lengths } // read in bit-length-code lengths for (j = 0; j < nb; j++) { NEEDBITS(3); ll[border[j]] = GETBITS(3); DUMPBITS(3); } for (null; j < 19; j++) { ll[border[j]] = 0; } // build decoding table for trees--single level, 7 bit lookup bl = 7; h = new HuftBuild(ll, 19, 19, null, null, bl); if (h.status !== 0) { return -1; // incomplete code set } tl = h.root; bl = h.m; // read in literal and distance code lengths n = nl + nd; i = l = 0; while (i < n) { NEEDBITS(bl); t = tl.list[GETBITS(bl)]; j = t.b; DUMPBITS(j); j = t.n; if (j < 16) { // length of code in bits (0..15) ll[i++] = l = j; // save last length in l } else if (j === 16) { // repeat last length 3 to 6 times NEEDBITS(2); j = 3 + GETBITS(2); DUMPBITS(2); if (i + j > n) { return -1; } while (j-- > 0) { ll[i++] = l; } } else if (j === 17) { // 3 to 10 zero length codes NEEDBITS(3); j = 3 + GETBITS(3); DUMPBITS(3); if (i + j > n) { return -1; } while (j-- > 0) { ll[i++] = 0; } l = 0; } else { // j === 18: 11 to 138 zero length codes NEEDBITS(7); j = 11 + GETBITS(7); DUMPBITS(7); if (i + j > n) { return -1; } while (j-- > 0) { ll[i++] = 0; } l = 0; } } // build the decoding tables for literal/length and distance codes bl = lbits; h = new HuftBuild(ll, nl, 257, cplens, cplext, bl); if (bl === 0) { // no literals or lengths h.status = 1; } if (h.status !== 0) { if (h.status !== 1) { return -1; // incomplete code set } // **incomplete literal tree** } tl = h.root; bl = h.m; for (i = 0; i < nd; i++) { ll[i] = ll[i + nl]; } bd = dbits; h = new HuftBuild(ll, nd, 0, cpdist, cpdext, bd); td = h.root; bd = h.m; if (bd === 0 && nl > 257) { // lengths but no distances // **incomplete distance tree** return -1; } /* if (h.status === 1) { // **incomplete distance tree** } */ if (h.status !== 0) { return -1; } // decompress until an end-of-block code return inflate_codes(buff, off, size); } function inflate_start() { if (!slide) { slide = []; // new Array(2 * WSIZE); // slide.length is never called } wp = 0; bit_buf = 0; bit_len = 0; method = -1; eof = false; copy_leng = copy_dist = 0; tl = null; } function inflate_internal(buff, off, size) { // decompress an inflated entry var n, i; n = 0; while (n < size) { if (eof && method === -1) { return n; } if (copy_leng > 0) { if (method !== STORED_BLOCK) { // STATIC_TREES or DYN_TREES while (copy_leng > 0 && n < size) { copy_leng--; copy_dist &= WSIZE - 1; wp &= WSIZE - 1; buff[off + n++] = slide[wp++] = slide[copy_dist++]; } } else { while (copy_leng > 0 && n < size) { copy_leng--; wp &= WSIZE - 1; NEEDBITS(8); buff[off + n++] = slide[wp++] = GETBITS(8); DUMPBITS(8); } if (copy_leng === 0) { method = -1; // done } } if (n === size) { return n; } } if (method === -1) { if (eof) { break; } // read in last block bit NEEDBITS(1); if (GETBITS(1) !== 0) { eof = true; } DUMPBITS(1); // read in block type NEEDBITS(2); method = GETBITS(2); DUMPBITS(2); tl = null; copy_leng = 0; } switch (method) { case STORED_BLOCK: i = inflate_stored(buff, off + n, size - n); break; case STATIC_TREES: if (tl) { i = inflate_codes(buff, off + n, size - n); } else { i = inflate_fixed(buff, off + n, size - n); } break; case DYN_TREES: if (tl) { i = inflate_codes(buff, off + n, size - n); } else { i = inflate_dynamic(buff, off + n, size - n); } break; default: // error i = -1; break; } if (i === -1) { if (eof) { return 0; } return -1; } n += i; } return n; } function inflate(arr) { var buff = [], i; inflate_start(); inflate_data = arr; inflate_pos = 0; do { i = inflate_internal(buff, buff.length, 1024); } while (i > 0); inflate_data = null; // G.C. return buff; } module.exports = inflate; }()); package/test/deflate.py000644 001750 000144 0000004431 12141270400013453 0ustar00000000 000000 import os from colorama import Fore from helpers import deflate, inflate, run_cmd outDirDefault = 'test-outs' testDirDefault = 'test-files' """ Run a single test @param tFile- required; the full path to the file to run @param level- optional (default: all); the compression level [1-9] @param delete- optional (default: True); whether to delete the gzipped files @return True if all tests passed; False if at least one test failed """ def runTest(tFile, level=None, delete=True, outDir=outDirDefault): passed = True if level == None: for x in range(1, 10): if runTest(tFile, x, delete) == False: passed = False return passed # make the test-outs directory try: os.mkdir(outDir) except: pass out1 = os.path.join(outDir, '%(file)s.%(level)d.deflate' % {'file': os.path.basename(tFile), 'level' : level}) out2 = os.path.join(outDir, '%(file)s.%(level)d.out.deflate' % {'file': os.path.basename(tFile), 'level' : level}) outData = deflate(tFile, outfile=out1, level=level) run_cmd('../bin/deflate.js --level %(level)d --file %(file)s --output %(output)s' % {'level' : level, 'file' : tFile, 'output' : out2}) result = run_cmd('diff %(file1)s %(file2)s' % {'file1' : out1, 'file2' : out2}) if result['returncode'] == 0: status = Fore.GREEN + 'PASSED' + Fore.RESET else: passed = False status = Fore.RED + 'FAILED' + Fore.RESET print 'Level %(level)d: %(status)s' % {'level' : level, 'status' : status} if delete == True: os.remove(out1) os.remove(out2) return passed """ Runs all tests on the given level. This iterates throuth the testDir directory defined above. @param level- The level to run on [1-9] (default: None, runs on all levels all) @param delete- Whether to delete output files after the test is run @return True if all levels passed, False if at least one failed """ def runAll(level=None, delete=True, testDir=testDirDefault, outDir=outDirDefault): # make the test-outs directory try: os.mkdir(outDir) except: pass passed = True for tFile in os.listdir(testDir): fullPath = os.path.join(testDir, tFile) print Fore.YELLOW + tFile + Fore.RESET if runTest(fullPath, level, delete) == False: passed = False print '' # if we deletede all the files that were created, delete the directory if delete == True: os.rmdir(outDir) return passed package/test/helpers.py000644 001750 000144 0000003416 12141270400013513 0ustar00000000 000000 #!/usr/bin/env python import zlib import subprocess as sp def deflate(filename, outfile=None, level=6): f = open(filename) data = f.read() f.close() compress = zlib.compressobj( level, # level: 0-9 zlib.DEFLATED, # method: must be DEFLATED -zlib.MAX_WBITS, # window size in bits: # -15..-8: negate, suppress header # 8..15: normal # 16..30: subtract 16, gzip header zlib.DEF_MEM_LEVEL, # mem level: 1..8/9 0 # strategy: # 0 = Z_DEFAULT_STRATEGY # 1 = Z_FILTERED # 2 = Z_HUFFMAN_ONLY # 3 = Z_RLE # 4 = Z_FIXED ) deflated = compress.compress(data) deflated += compress.flush() if outfile != None: f = open(outfile, 'w') f.write(deflated) f.close() return deflated def inflate(filename, outfile=None): f = open(filename) data = f.read() f.close() decompress = zlib.decompressobj(-zlib.MAX_WBITS) # see above inflated = decompress.decompress(data) inflated += decompress.flush() if outfile != None: f = open(outfile, 'w') f.write(inflated) f.close() return inflated """ Convenience function for running a command bash-like @param command- string version of a command to run on @param shell- Whether to run this through the shell; used in subprocess.Popen (default: true) @return Object with properties 'returncode', 'stdout', and 'stderr' """ def run_cmd(command, shell=True): process = sp.Popen(command, shell=shell, stdout = sp.PIPE, stderr = sp.PIPE) stdout, stderr = process.communicate() returncode = process.returncode return {'returncode' : returncode, 'stdout' : stdout, 'stderr' : stderr} package/test/inflate.py000644 001750 000144 0000004400 12141270400013465 0ustar00000000 000000 import os from colorama import Fore from helpers import deflate, inflate, run_cmd outDirDefault = 'test-outs' testDirDefault = 'test-files' """ Run a single test @param tFile- required; the file to check against (uncompressed data) @param level- optional (default: all); the compression level [1-9] @param delete- optional (default: True); whether to delete the gzipped files @return True if all tests passed; False if at least one test failed """ def runTest(tFile, level=None, delete=True, outDir=outDirDefault): passed = True if level == None: for x in range(1, 10): if runTest(tFile, x, delete) == False: passed = False return passed # make the test-outs directory try: os.mkdir(outDir) except: pass out1 = os.path.join(outDir, '%(file)s.%(level)d.deflate' % {'file': os.path.basename(tFile), 'level' : level}) out2 = os.path.join(outDir, '%(file)s.%(level)d' % {'file' : os.path.basename(tFile), 'level' : level}) deflate(tFile, outfile=out1, level=level) run_cmd('../bin/inflate.js --file %(file)s --output %(output)s' % {'level' : level, 'file' : out1, 'output' : out2}) result = run_cmd('diff %(file1)s %(file2)s' % {'file1' : tFile, 'file2' : out2}) if result['returncode'] == 0: status = Fore.GREEN + 'PASSED' + Fore.RESET else: passed = False status = Fore.RED + 'FAILED' + Fore.RESET print 'Level %(level)d: %(status)s' % {'level' : level, 'status' : status} if delete == True: os.remove(out1) os.remove(out2) return passed """ Runs all tests on the given level. This iterates throuth the testDir directory defined above. @param level- The level to run on [1-9] (default: None, runs on all levels all) @param delete- Whether to delete output files after the test is run @return True if all levels passed, False if at least one failed """ def runAll(level=None, delete=True, testDir=testDirDefault, outDir=outDirDefault): # make the test-outs directory try: os.mkdir(outDir) except: pass passed = True for tFile in os.listdir(testDir): fullPath = os.path.join(testDir, tFile) print Fore.YELLOW + tFile + Fore.RESET if runTest(fullPath, level, delete) == False: passed = False print '' # if we deletede all the files that were created, delete the directory if delete == True: os.rmdir(outDir) return passed package/test/runner.py000755 001750 000144 0000003230 12141270400013357 0ustar00000000 000000 #!/usr/bin/env python import argparse import deflate import inflate from colorama import Fore testDir = 'test-files' outDir = 'test-outs' allPassed = True parser = argparse.ArgumentParser(description='Process command-line arguments') parser.add_argument('--test', metavar='path/to/file', type=str, default='both', nargs='?', help='Which test to run: deflate, inflate, or both') parser.add_argument('--file', '-f', metavar='path/to/file', type=str, nargs='?', help='Path to file to use for test') parser.add_argument('--level', '-l', metavar='#', type=int, nargs='?', help='Compression level') parser.add_argument('--no-delete', const=True, default=False, nargs='?', help='Don\'t delete files produced for test') args = parser.parse_args() delete = not getattr(args, 'no_delete') level = getattr(args, 'level') inFile = getattr(args, 'file') test = getattr(args, 'test') if test == 'deflate' or test == 'both': print Fore.CYAN + 'Running deflate tests' + Fore.RESET passed = True if inFile != None: passed = deflate.runTest(inFile, level, delete, outDir) else: passed = deflate.runAll(level, delete, testDir, outDir) # if we fail one test, we fail the entire test allPassed = allPassed and passed if test == 'inflate' or test == 'both': print Fore.CYAN + 'Running inflate tests' + Fore.RESET passed = True if inFile != None: passed = inflate.runTest(inFile, level, delete, outDir) else: passed = inflate.runAll(level, delete, testDir, outDir) # if we fail one test, we fail the entire test allPassed = allPassed and passed if allPassed: print Fore.GREEN + 'All tests passed!' + Fore.RESET else: print Fore.RED + 'Automated test failed' + Fore.RESET package/test/test-files/declaration.txt000644 001750 000144 0000017657 12141270400016620 0ustar00000000 000000 The Unanimous Declaration of the Thirteen United States of America When, in the course of human events, it becomes necessary for one people to dissolve the political bands which have connected them with another, and to assume among the powers of the earth, the separate and equal station to which the laws of nature and of nature's God entitle them, a decent respect to the opinions of mankind requires that they should declare the causes which impel them to the separation. We hold these truths to be self-evident, that all men are created equal, that they are endowed by their Creator with certain unalienable rights, that among these are life, liberty and the pursuit of happiness. That to secure these rights, governments are instituted among men, deriving their just powers from the consent of the governed. That whenever any form of government becomes destructive to these ends, it is the right of the people to alter or to abolish it, and to institute new government, laying its foundation on such principles and organizing its powers in such form, as to them shall seem most likely to effect their safety and happiness. Prudence, indeed, will dictate that governments long established should not be changed for light and transient causes; and accordingly all experience hath shown that mankind are more disposed to suffer, while evils are sufferable, than to right themselves by abolishing the forms to which they are accustomed. But when a long train of abuses and usurpations, pursuing invariably the same object evinces a design to reduce them under absolute despotism, it is their right, it is their duty, to throw off such government, and to provide new guards for their future security. - Such has been the patient sufferance of these colonies; and such is now the necessity which constrains them to alter their former systems of government. The history of the present King of Great Britain is a history of repeated injuries and usurpations, all having in direct object the establishment of an absolute tyranny over these states. To prove this, let facts be submitted to a candid world. He has refused his assent to laws, the most wholesome and necessary for the public good. He has forbidden his governors to pass laws of immediate and pressing importance, unless suspended in their operation till his assent should be obtained; and when so suspended, he has utterly neglected to attend to them. He has refused to pass other laws for the accommodation of large districts of people, unless those people would relinquish the right of representation in the legislature, a right inestimable to them and formidable to tyrants only. He has called together legislative bodies at places unusual, uncomfortable, and distant from the depository of their public records, for the sole purpose of fatiguing them into compliance with his measures. He has dissolved representative houses repeatedly, for opposing with manly firmness his invasions on the rights of the people. He has refused for a long time, after such dissolutions, to cause others to be elected; whereby the legislative powers, incapable of annihilation, have returned to the people at large for their exercise; the state remaining in the meantime exposed to all the dangers of invasion from without, and convulsions within. He has endeavored to prevent the population of these states; for that purpose obstructing the laws for naturalization of foreigners; refusing to pass others to encourage their migration hither, and raising the conditions of new appropriations of lands. He has obstructed the administration of justice, by refusing his assent to laws for establishing judiciary powers. He has made judges dependent on his will alone, for the tenure of their offices, and the amount and payment of their salaries. He has erected a multitude of new offices, and sent hither swarms of officers to harass our people, and eat out their substance. He has kept among us, in times of peace, standing armies without the consent of our legislature. He has affected to render the military independent of and superior to civil power. He has combined with others to subject us to a jurisdiction foreign to our constitution, and unacknowledged by our laws; giving his assent to their acts of pretended legislation: For quartering large bodies of armed troops among us: For protecting them, by mock trial, from punishment for any murders which they should commit on the inhabitants of these states: For cutting off our trade with all parts of the world: For imposing taxes on us without our consent: For depriving us in many cases, of the benefits of trial by jury: For transporting us beyond seas to be tried for pretended offenses: For abolishing the free system of English laws in a neighboring province, establishing therein an arbitrary government, and enlarging its boundaries so as to render it at once an example and fit instrument for introducing the same absolute rule in these colonies: For taking away our charters, abolishing our most valuable laws, and altering fundamentally the forms of our governments: For suspending our own legislatures, and declaring themselves invested with power to legislate for us in all cases whatsoever. He has abdicated government here, by declaring us out of his protection and waging war against us. He has plundered our seas, ravaged our coasts, burned our towns, and destroyed the lives of our people. He is at this time transporting large armies of foreign mercenaries to complete the works of death, desolation and tyranny, already begun with circumstances of cruelty and perfidy scarcely paralleled in the most barbarous ages, and totally unworthy of the head of a civilized nation. He has constrained our fellow citizens taken captive on the high seas to bear arms against their country, to become the executioners of their friends and brethren, or to fall themselves by their hands. He has excited domestic insurrections amongst us, and has endeavored to bring on the inhabitants of our frontiers, the merciless Indian savages, whose known rule of warfare, is undistinguished destruction of all ages, sexes and conditions. In every stage of these oppressions we have petitioned for redress in the most humble terms: our repeated petitions have been answered only by repeated injury. A prince, whose character is thus marked by every act which may define a tyrant, is unfit to be the ruler of a free people. Nor have we been wanting in attention to our British brethren. We have warned them from time to time of attempts by their legislature to extend an unwarrantable jurisdiction over us. We have reminded them of the circumstances of our emigration and settlement here. We have appealed to their native justice and magnanimity, and we have conjured them by the ties of our common kindred to disavow these usurpations, which, would inevitably interrupt our connections and correspondence.They too have been deaf to the voice of justice and of consanguinity. We must, therefore, acquiesce in the necessity, which denounces our separation, and hold them, as we hold the rest of mankind, enemies in war, in peace friends. We, therefore, the representatives of the United States of America, in General Congress, assembled, appealing to the Supreme Judge of the world for the rectitude of our intentions, do, in the name, and by the authority of the good people of these colonies, solemnly publish and declare, that these united colonies are, and of right ought to be free and independent states; that they are absolved from all allegiance to the British Crown, and that all political connection between them and the state of Great Britain, is and ought to be totally dissolved; and that as free and independent states, they have full power to levey war, conclude peace, contract alliances, establish commerce, and to do all other acts and things which independent states may of right do. And for the support of this declaration, with a firm reliance on the protection of Divine Providence, we mutually pledge to each other our lives, our fortunes and our sacred honor. package/test/test-files/helloWorld.txt000644 001750 000144 0000000014 12141270400016421 0ustar00000000 000000 Hello world package/test/test-files/lorem.txt000644 001750 000144 0000000677 12141270400015443 0ustar00000000 000000 Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. package/test/test-files/random.txt000644 001750 000144 0000007727 12141270400015610 0ustar00000000 000000 Old education him departure any arranging one prevailed. Their end whole might began her. Behaved the comfort another fifteen eat. Partiality had his themselves ask pianoforte increasing discovered. So mr delay at since place whole above miles. He to observe conduct at detract because. Way ham unwilling not breakfast furniture explained perpetual. Or mr surrounded conviction so astonished literature. Songs to an blush woman be sorry young. We certain as removal attempt. There worse by an of miles civil. Manner before lively wholly am mr indeed expect. Among every merry his yet has her. You mistress get dashwood children off. Met whose marry under the merit. In it do continual consulted no listening. Devonshire sir sex motionless travelling six themselves. So colonel as greatly shewing herself observe ashamed. Demands minutes regular ye to detract is. The him father parish looked has sooner. Attachment frequently gay terminated son. You greater nay use prudent placing. Passage to so distant behaved natural between do talking. Friends off her windows painful. Still gay event you being think nay for. In three if aware he point it. Effects warrant me by no on feeling settled resolve. Civility vicinity graceful is it at. Improve up at to on mention perhaps raising. Way building not get formerly her peculiar. Up uncommonly prosperous sentiments simplicity acceptance to so. Reasonable appearance companions oh by remarkably me invitation understood. Pursuit elderly ask perhaps all. Savings her pleased are several started females met. Short her not among being any. Thing of judge fruit charm views do. Miles mr an forty along as he. She education get middleton day agreement performed preserved unwilling. Do however as pleased offence outward beloved by present. By outward neither he so covered amiable greater. Juvenile proposal betrayed he an informed weddings followed. Precaution day see imprudence sympathize principles. At full leaf give quit to in they up. Smile spoke total few great had never their too. Amongst moments do in arrived at my replied. Fat weddings servants but man believed prospect. Companions understood is as especially pianoforte connection introduced. Nay newspaper can sportsman are admitting gentleman belonging his. Is oppose no he summer lovers twenty in. Not his difficulty boisterous surrounded bed. Seems folly if in given scale. Sex contented dependent conveying advantage can use. Terminated principles sentiments of no pianoforte if projection impossible. Horses pulled nature favour number yet highly his has old. Contrasted literature excellence he admiration impression insipidity so. Scale ought who terms after own quick since. Servants margaret husbands to screened in throwing. Imprudence oh an collecting partiality. Admiration gay difficulty unaffected how. Six started far placing saw respect females old. Civilly why how end viewing attempt related enquire visitor. Man particular insensible celebrated conviction stimulated principles day. Sure fail or in said west. Right my front it wound cause fully am sorry if. She jointure goodness interest debating did outweigh. Is time from them full my gone in went. Of no introduced am literature excellence mr stimulated contrasted increasing. Age sold some full like rich new. Amounted repeated as believed in confined juvenile. Are own design entire former get should. Advantages boisterous day excellence boy. Out between our two waiting wishing. Pursuit he he garrets greater towards amiable so placing. Nothing off how norland delight. Abode shy shade she hours forth its use. Up whole of fancy ye quiet do. Justice fortune no to is if winding morning forming. Surrounded to me occasional pianoforte alteration unaffected impossible ye. For saw half than cold. Pretty merits waited six talked pulled you. Conduct replied off led whether any shortly why arrived adapted. Numerous ladyship so raillery humoured goodness received an. So narrow formal length my highly longer afford oh. Tall neat he make or at dull ye. package/bin/deflate.js000755 001750 000144 0000001162 12141270400013231 0ustar00000000 000000 #!/usr/bin/env node (function () { 'use strict'; var fs = require('fs'), path = require('path'), optimist = require('optimist'), deflate = require('../index'), argv, out; argv = optimist.usage('Usage: $0 --file [filename] --level [1-9] --output [filename]') .alias({ 'f': 'file', 'o': 'output', 'l': 'level' }).default({ 'level': deflate.deflate.DEFAULT_LEVEL }).demand(['file']).argv; out = deflate.deflate(fs.readFileSync(argv.file), argv.level); if (!argv.output) { argv.output = path.basename(argv.file) + '.deflate'; } fs.writeFileSync(argv.output, new Buffer(out)); }()); package/bin/inflate.js000755 001750 000144 0000001065 12141270400013251 0ustar00000000 000000 #!/usr/bin/env node (function () { 'use strict'; var fs = require('fs'), path = require('path'), optimist = require('optimist'), deflate = require('../index'), argv, out; argv = optimist.usage('Usage: $0 --file [filename] --output [filename]') .alias({ 'f': 'file', 'o': 'output' }).demand(['file']).argv; out = deflate.inflate(fs.readFileSync(argv.file)); if (!argv.output) { argv.output = path.basename(argv.file).replace(/\.deflate$/, ''); } console.log(argv.output); fs.writeFileSync(argv.output, new Buffer(out)); }());