add deflate signatures

lib/deflate.js

@@ -0,0 +1,50 @@
+var zlib = require('zlib/deflate.js');
+/**
+ * Deflate
+ *
+ * @param {Object} [options] zlib options
+ * @constructor
+ */
+var Deflate = function(options) {
+
+}
+
+/**
+ * Compresses the input data and fills output buffer with compressed data.
+ * @return {Array|Uint8Array} compressed data
+ */
+Deflate.prototype.deflate = function(input) {
+
+}
+
+Deflate.prototype.flush = function() {
+
+}
+
+Deflate.prototype.finish = function() {
+
+}
+
+Deflate.prototype.onData = function(output) {
+
+}
+
+Deflate.prototype.onEnd = function(error) {
+
+}
+
+exports.Deflate = Deflate;
+
+/**
+ * Compresses the input data
+ * @param input
+ * @param [options]
+ * @returns {Array|Uint8Array}
+ */
+exports.deflate = function(input, options) {
+
+}
+
+exports.deflateRaw = function(input, options) {
+
+}

lib/zlib/constants.js

@@ -0,0 +1,33 @@
+module.exports = {
+  Z_NO_FLUSH:         0,
+  Z_PARTIAL_FLUSH:    1,
+  Z_SYNC_FLUSH:       2,
+  Z_FULL_FLUSH:       3,
+  Z_FINISH:           4,
+  Z_BLOCK:            5,
+  Z_TREES:            6,
+
+  /* Allowed flush values; see deflate() and inflate() below for details */
+  Z_OK:               0,
+  Z_STREAM_END:       1,
+  Z_NEED_DICT:        2,
+  Z_ERRNO:         (-1),
+  Z_STREAM_ERROR:  (-2),
+  Z_DATA_ERROR:    (-3),
+  Z_MEM_ERROR:     (-4),
+  Z_BUF_ERROR:     (-5),
+  Z_VERSION_ERROR: (-6),
+  /* Return codes for the compression/decompression functions. Negative values
+  * are errors, positive values are used for special but normal events.
+  */
+  Z_NO_COMPRESSION:         0,
+  Z_BEST_SPEED:             1,
+  Z_BEST_COMPRESSION:       9,
+  Z_DEFAULT_COMPRESSION:   -1,
+  /* compression levels */
+  Z_FILTERED:               1,
+  Z_HUFFMAN_ONLY:           2,
+  Z_RLE:                    3,
+  Z_FIXED:                  4,
+  Z_DEFAULT_STRATEGY:       0
+}

lib/zlib/deflate.js

@@ -0,0 +1,274 @@
+var consts = require('constants');
+
+function internal_state() {
+  this.status = 0;            /* as the name implies */
+  this.pending_buf = -1;    /* output still pending */
+  this.pending_buf_size = 0;  /* size of pending_buf */
+  this.pending_out = -1;    /* next pending byte to output to the stream */
+  this.pending = 0;           /* nb of bytes in the pending buffer */
+  this.last_flush = -1;     /* value of flush param for previous deflate call */
+
+  this.w_size = 0;        /* LZ77 window size (32K by default) */
+  this.w_bits = 0;        /* log2(w_size)  (8..16) */
+  this.w_mask = 0;        /* w_size - 1 */
+
+  this.window = -1;
+  /* Sliding window. Input bytes are read into the second half of the window,
+   * and move to the first half later to keep a dictionary of at least wSize
+   * bytes. With this organization, matches are limited to a distance of
+   * wSize-MAX_MATCH bytes, but this ensures that IO is always
+   * performed with a length multiple of the block size.
+   */
+
+  this.window_size = 0;
+  /* Actual size of window: 2*wSize, except when the user input buffer
+   * is directly used as sliding window.
+   */
+
+  this.prev = -1;
+  /* Link to older string with same hash index. To limit the size of this
+   * array to 64K, this link is maintained only for the last 32K strings.
+   * An index in this array is thus a window index modulo 32K.
+   */
+
+  this.head = -1; /* Heads of the hash chains or NIL. */
+
+  this.ins_h      = 0;      /* hash index of string to be inserted */
+  this.hash_size  = 0;      /* number of elements in hash table */
+  this.hash_bits  = 0;      /* log2(hash_size) */
+  this.hash_mask  = 0;      /* hash_size-1 */
+
+  this.hash_shift = 0;
+  /* Number of bits by which ins_h must be shifted at each input
+   * step. It must be such that after MIN_MATCH steps, the oldest
+   * byte no longer takes part in the hash key, that is:
+   *   hash_shift * MIN_MATCH >= hash_bits
+   */
+
+  this.block_start = 0;
+  /* Window position at the beginning of the current output block. Gets
+   * negative when the window is moved backwards.
+   */
+
+  this.match_length       = 0;         /* length of best match */
+  this.prev_match         = 0;         /* previous match */
+  this.match_available    = 1;         /* set if previous match exists */
+  this.strstart           = 0;         /* start of string to insert */
+  this.match_start        = 0;         /* start of matching string */
+  this.lookahead          = 0;         /* number of valid bytes ahead in window */
+
+  this.prev_length        = 0;
+  /* Length of the best match at previous step. Matches not greater than this
+   * are discarded. This is used in the lazy match evaluation.
+   */
+
+  this.max_chain_length = 0;
+  /* To speed up deflation, hash chains are never searched beyond this
+   * length.  A higher limit improves compression ratio but degrades the
+   * speed.
+   */
+
+  this.max_lazy_match = 0;
+  /* Attempt to find a better match only when the current match is strictly
+   * smaller than this value. This mechanism is used only for compression
+   * levels >= 4.
+   */
+  this.max_insert_length = 0;
+  /* Insert new strings in the hash table only if the match length is not
+   * greater than this length. This saves time but degrades compression.
+   * max_insert_length is used only for compression levels <= 3.
+   */
+
+  this.level = 0;    /* compression level (1..9) */
+  this.strategy = 0; /* favor or force Huffman coding*/
+
+  this.good_match = 0;
+  /* Use a faster search when the previous match is longer than this */
+
+  this.nice_match = 0; /* Stop searching when current match exceeds this */
+}
+
+function deflateInit (strm, level) {
+
+}
+
+function deflateInit2 (strm, level, method, windowBits, memLevel, strategy) {
+
+}
+
+function deflateSetDictionary (strm, dictionary, dictLength) {
+
+}
+
+function deflateResetKeep (strm) {
+
+}
+
+function deflateReset (strm) {
+
+}
+
+function deflateParams (strm,level,strategy) {
+
+}
+
+function deflateSetHeader (strm, head) {
+
+}
+
+function deflateBound(strm, sourceLen) {
+
+}
+
+function deflatePending (strm, pending, bits) {
+
+}
+
+/* =========================================================================
+ * Put a short in the pending buffer. The 16-bit value is put in MSB order.
+ * IN assertion: the stream state is correct and there is enough room in
+ * pending_buf.
+ */
+function putShortMSB (s, b) {
+
+}
+
+/* =========================================================================
+ * Flush as much pending output as possible. All deflate() output goes
+ * through this function so some applications may wish to modify it
+ * to avoid allocating a large strm->next_out buffer and copying into it.
+ * (See also read_buf()).
+ */
+function flush_pending(strm) {
+
+}
+
+function deflate (strm, flush) {
+
+}
+
+function deflateEnd (strm) {
+
+}
+
+/* =========================================================================
+ * Copy the source state to the destination state
+ */
+function deflateCopy (dest, source) {
+
+}
+
+/* ===========================================================================
+ * Read a new buffer from the current input stream, update the adler32
+ * and total number of bytes read.  All deflate() input goes through
+ * this function so some applications may wish to modify it to avoid
+ * allocating a large strm->next_in buffer and copying from it.
+ * (See also flush_pending()).
+ */
+function read_buf(strm, buf, size) {
+
+}
+
+/* ===========================================================================
+ * Initialize the "longest match" routines for a new zlib stream
+ */
+function lm_init (s) {
+
+}
+
+/* ===========================================================================
+ * 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
+ * OUT assertion: the match length is not greater than s->lookahead.
+ */
+function longest_match(s, cur_match) {
+
+}
+
+/* ===========================================================================
+ * Fill the window when the lookahead becomes insufficient.
+ * Updates strstart and lookahead.
+ *
+ * IN assertion: lookahead < MIN_LOOKAHEAD
+ * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
+ *    At least one byte has been read, or avail_in == 0; reads are
+ *    performed for at least two bytes (required for the zip translate_eol
+ *    option -- not supported here).
+ */
+function fill_window(s) {
+
+}
+
+/* ===========================================================================
+ * Copy without compression as much as possible from the input stream, return
+ * the current block state.
+ * This function does not insert new strings in the dictionary since
+ * uncompressible data is probably not useful. This function is used
+ * only for the level=0 compression option.
+ * NOTE: this function should be optimized to avoid extra copying from
+ * window to pending_buf.
+ */
+function deflate_stored(s, flush) {
+
+}
+
+/* ===========================================================================
+ * Compress as much as possible from the input stream, return the current
+ * block state.
+ * This function does not perform lazy evaluation of 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(s, flush) {
+
+}
+
+/* ===========================================================================
+ * 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_slow(s, flush) {
+
+}
+
+/* ===========================================================================
+ * For Z_RLE, simply look for runs of bytes, generate matches only of distance
+ * one.  Do not maintain a hash table.  (It will be regenerated if this run of
+ * deflate switches away from Z_RLE.)
+ */
+function deflate_rle(s, flush) {
+
+}
+
+/* ===========================================================================
+ * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.
+ * (It will be regenerated if this run of deflate switches away from Huffman.)
+ */
+function deflate_huff(s, flush) {
+
+}
+
+exports.deflateInit = deflateInit;
+
+exports.deflateInit2 = deflateInit2;
+
+exports.deflateSetDictionary = deflateSetDictionary;
+
+exports.deflateReset = deflateReset;
+
+exports.deflateParams = deflateParams;
+
+exports.deflateSetHeader = deflateSetHeader;
+
+exports.deflateBound = deflateBound;
+
+exports.deflatePending = deflatePending;
+
+exports.deflate = deflate;
+
+exports.deflateEnd = deflateEnd;

lib/zlib/zstream.js

@@ -0,0 +1,24 @@
+function ZStream() {
+  /* next input byte */
+  this.next_in = -1;
+  /* number of bytes available at next_in */
+  this.avail_in = 0;
+  /* total number of input bytes read so far */
+  this.total_in = 0;
+  /* next output byte should be put there */
+  this.next_out = -1;
+  /* remaining free space at next_out */
+  this.avail_out = 0;
+  /* total number of bytes output so far */
+  this.total_out = 0;
+  /* last error message, NULL if no error */
+  this.msg = -1;
+  /* not visible by applications */
+  this.state = -1;
+  /* best guess about the data type: binary or text */
+  this.data_type = 2;
+  /* adler32 value of the uncompressed data */
+  this.adler = 0;
+}
+
+module.exports = ZStream;