site/j2s/JU/Deflate.js

   1 Clazz.declarePackage ("JU");\r
   2 Clazz.load (["JU.Tree"], "JU.Deflate", ["JU.CRC32", "$.GZIPHeader", "$.StaticTree"], function () {\r
   3 c$ = Clazz.decorateAsClass (function () {\r
   4 this.strm = null;\r
   5 this.status = 0;\r
   6 this.pending_buf = null;\r
   7 this.pending_buf_size = 0;\r
   8 this.pending_out = 0;\r
   9 this.pending = 0;\r
  10 this.wrap = 1;\r
  11 this.data_type = 0;\r
  12 this.method = 0;\r
  13 this.last_flush = 0;\r
  14 this.w_size = 0;\r
  15 this.w_bits = 0;\r
  16 this.w_mask = 0;\r
  17 this.window = null;\r
  18 this.window_size = 0;\r
  19 this.prev = null;\r
  20 this.head = null;\r
  21 this.ins_h = 0;\r
  22 this.hash_size = 0;\r
  23 this.hash_bits = 0;\r
  24 this.hash_mask = 0;\r
  25 this.hash_shift = 0;\r
  26 this.block_start = 0;\r
  27 this.match_length = 0;\r
  28 this.prev_match = 0;\r
  29 this.match_available = 0;\r
  30 this.strstart = 0;\r
  31 this.match_start = 0;\r
  32 this.lookahead = 0;\r
  33 this.prev_length = 0;\r
  34 this.max_chain_length = 0;\r
  35 this.max_lazy_match = 0;\r
  36 this.level = 0;\r
  37 this.strategy = 0;\r
  38 this.good_match = 0;\r
  39 this.nice_match = 0;\r
  40 this.dyn_ltree = null;\r
  41 this.dyn_dtree = null;\r
  42 this.bl_tree = null;\r
  43 this.l_desc = null;\r
  44 this.d_desc = null;\r
  45 this.bl_desc = null;\r
  46 this.bl_count = null;\r
  47 this.heap = null;\r
  48 this.heap_len = 0;\r
  49 this.heap_max = 0;\r
  50 this.depth = null;\r
  51 this.l_buf = 0;\r
  52 this.lit_bufsize = 0;\r
  53 this.last_lit = 0;\r
  54 this.d_buf = 0;\r
  55 this.opt_len = 0;\r
  56 this.static_len = 0;\r
  57 this.matches = 0;\r
  58 this.last_eob_len = 0;\r
  59 this.bi_buf = 0;\r
  60 this.bi_valid = 0;\r
  61 this.gheader = null;\r
  62 Clazz.instantialize (this, arguments);\r
  63 }, JU, "Deflate");\r
  64 Clazz.prepareFields (c$, function () {\r
  65 this.l_desc =  new JU.Tree ();\r
  66 this.d_desc =  new JU.Tree ();\r
  67 this.bl_desc =  new JU.Tree ();\r
  68 this.bl_count =  Clazz.newShortArray (16, 0);\r
  69 this.heap =  Clazz.newIntArray (573, 0);\r
  70 this.depth =  Clazz.newByteArray (573, 0);\r
  71 });\r
  72 Clazz.makeConstructor (c$, \r
  73 function (strm) {\r
  74 this.strm = strm;\r
  75 this.dyn_ltree =  Clazz.newShortArray (1146, 0);\r
  76 this.dyn_dtree =  Clazz.newShortArray (122, 0);\r
  77 this.bl_tree =  Clazz.newShortArray (78, 0);\r
  78 }, "JU.ZStream");\r
  79 Clazz.defineMethod (c$, "deflateInit", \r
  80 function (level) {\r
  81 return this.deflateInit2 (level, 15);\r
  82 }, "~N");\r
  83 Clazz.defineMethod (c$, "deflateInit2", \r
  84 function (level, bits) {\r
  85 return this.deflateInit5 (level, 8, bits, 8, 0);\r
  86 }, "~N,~N");\r
  87 Clazz.defineMethod (c$, "deflateInit3", \r
  88 function (level, bits, memlevel) {\r
  89 return this.deflateInit5 (level, 8, bits, memlevel, 0);\r
  90 }, "~N,~N,~N");\r
  91 Clazz.defineMethod (c$, "lm_init", \r
  92 function () {\r
  93 this.window_size = 2 * this.w_size;\r
  94 this.head[this.hash_size - 1] = 0;\r
  95 for (var i = 0; i < this.hash_size - 1; i++) {\r
  96 this.head[i] = 0;\r
  97 }\r
  98 this.max_lazy_match = JU.Deflate.config_table[this.level].max_lazy;\r
  99 this.good_match = JU.Deflate.config_table[this.level].good_length;\r
 100 this.nice_match = JU.Deflate.config_table[this.level].nice_length;\r
 101 this.max_chain_length = JU.Deflate.config_table[this.level].max_chain;\r
 102 this.strstart = 0;\r
 103 this.block_start = 0;\r
 104 this.lookahead = 0;\r
 105 this.match_length = this.prev_length = 2;\r
 106 this.match_available = 0;\r
 107 this.ins_h = 0;\r
 108 });\r
 109 Clazz.defineMethod (c$, "tr_init", \r
 110 function () {\r
 111 this.l_desc.dyn_tree = this.dyn_ltree;\r
 112 this.l_desc.stat_desc = JU.StaticTree.static_l_desc;\r
 113 this.d_desc.dyn_tree = this.dyn_dtree;\r
 114 this.d_desc.stat_desc = JU.StaticTree.static_d_desc;\r
 115 this.bl_desc.dyn_tree = this.bl_tree;\r
 116 this.bl_desc.stat_desc = JU.StaticTree.static_bl_desc;\r
 117 this.bi_buf = 0;\r
 118 this.bi_valid = 0;\r
 119 this.last_eob_len = 8;\r
 120 this.init_block ();\r
 121 });\r
 122 Clazz.defineMethod (c$, "init_block", \r
 123 function () {\r
 124 for (var i = 0; i < 286; i++) this.dyn_ltree[i * 2] = 0;\r
 125 \r
 126 for (var i = 0; i < 30; i++) this.dyn_dtree[i * 2] = 0;\r
 127 \r
 128 for (var i = 0; i < 19; i++) this.bl_tree[i * 2] = 0;\r
 129 \r
 130 this.dyn_ltree[512] = 1;\r
 131 this.opt_len = this.static_len = 0;\r
 132 this.last_lit = this.matches = 0;\r
 133 });\r
 134 Clazz.defineMethod (c$, "pqdownheap", \r
 135 function (tree, k) {\r
 136 var v = this.heap[k];\r
 137 var j = k << 1;\r
 138 while (j <= this.heap_len) {\r
 139 if (j < this.heap_len && JU.Deflate.smaller (tree, this.heap[j + 1], this.heap[j], this.depth)) {\r
 140 j++;\r
 141 }if (JU.Deflate.smaller (tree, v, this.heap[j], this.depth)) break;\r
 142 this.heap[k] = this.heap[j];\r
 143 k = j;\r
 144 j <<= 1;\r
 145 }\r
 146 this.heap[k] = v;\r
 147 }, "~A,~N");\r
 148 c$.smaller = Clazz.defineMethod (c$, "smaller", \r
 149 function (tree, n, m, depth) {\r
 150 var tn2 = tree[n * 2];\r
 151 var tm2 = tree[m * 2];\r
 152 return (tn2 < tm2 || (tn2 == tm2 && depth[n] <= depth[m]));\r
 153 }, "~A,~N,~N,~A");\r
 154 Clazz.defineMethod (c$, "scan_tree", \r
 155 function (tree, max_code) {\r
 156 var n;\r
 157 var prevlen = -1;\r
 158 var curlen;\r
 159 var nextlen = tree[1];\r
 160 var count = 0;\r
 161 var max_count = 7;\r
 162 var min_count = 4;\r
 163 if (nextlen == 0) {\r
 164 max_count = 138;\r
 165 min_count = 3;\r
 166 }tree[(max_code + 1) * 2 + 1] = 0xffff;\r
 167 for (n = 0; n <= max_code; n++) {\r
 168 curlen = nextlen;\r
 169 nextlen = tree[(n + 1) * 2 + 1];\r
 170 if (++count < max_count && curlen == nextlen) {\r
 171 continue;\r
 172 } else if (count < min_count) {\r
 173 this.bl_tree[curlen * 2] += count;\r
 174 } else if (curlen != 0) {\r
 175 if (curlen != prevlen) this.bl_tree[curlen * 2]++;\r
 176 this.bl_tree[32]++;\r
 177 } else if (count <= 10) {\r
 178 this.bl_tree[34]++;\r
 179 } else {\r
 180 this.bl_tree[36]++;\r
 181 }count = 0;\r
 182 prevlen = curlen;\r
 183 if (nextlen == 0) {\r
 184 max_count = 138;\r
 185 min_count = 3;\r
 186 } else if (curlen == nextlen) {\r
 187 max_count = 6;\r
 188 min_count = 3;\r
 189 } else {\r
 190 max_count = 7;\r
 191 min_count = 4;\r
 192 }}\r
 193 }, "~A,~N");\r
 194 Clazz.defineMethod (c$, "build_bl_tree", \r
 195 function () {\r
 196 var max_blindex;\r
 197 this.scan_tree (this.dyn_ltree, this.l_desc.max_code);\r
 198 this.scan_tree (this.dyn_dtree, this.d_desc.max_code);\r
 199 this.bl_desc.build_tree (this);\r
 200 for (max_blindex = 18; max_blindex >= 3; max_blindex--) {\r
 201 if (this.bl_tree[JU.Tree.bl_order[max_blindex] * 2 + 1] != 0) break;\r
 202 }\r
 203 this.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;\r
 204 return max_blindex;\r
 205 });\r
 206 Clazz.defineMethod (c$, "send_all_trees", \r
 207 function (lcodes, dcodes, blcodes) {\r
 208 var rank;\r
 209 this.send_bits (lcodes - 257, 5);\r
 210 this.send_bits (dcodes - 1, 5);\r
 211 this.send_bits (blcodes - 4, 4);\r
 212 for (rank = 0; rank < blcodes; rank++) {\r
 213 this.send_bits (this.bl_tree[JU.Tree.bl_order[rank] * 2 + 1], 3);\r
 214 }\r
 215 this.send_tree (this.dyn_ltree, lcodes - 1);\r
 216 this.send_tree (this.dyn_dtree, dcodes - 1);\r
 217 }, "~N,~N,~N");\r
 218 Clazz.defineMethod (c$, "send_tree", \r
 219 function (tree, max_code) {\r
 220 var n;\r
 221 var prevlen = -1;\r
 222 var curlen;\r
 223 var nextlen = tree[1];\r
 224 var count = 0;\r
 225 var max_count = 7;\r
 226 var min_count = 4;\r
 227 if (nextlen == 0) {\r
 228 max_count = 138;\r
 229 min_count = 3;\r
 230 }for (n = 0; n <= max_code; n++) {\r
 231 curlen = nextlen;\r
 232 nextlen = tree[(n + 1) * 2 + 1];\r
 233 if (++count < max_count && curlen == nextlen) {\r
 234 continue;\r
 235 } else if (count < min_count) {\r
 236 do {\r
 237 this.send_code (curlen, this.bl_tree);\r
 238 } while (--count != 0);\r
 239 } else if (curlen != 0) {\r
 240 if (curlen != prevlen) {\r
 241 this.send_code (curlen, this.bl_tree);\r
 242 count--;\r
 243 }this.send_code (16, this.bl_tree);\r
 244 this.send_bits (count - 3, 2);\r
 245 } else if (count <= 10) {\r
 246 this.send_code (17, this.bl_tree);\r
 247 this.send_bits (count - 3, 3);\r
 248 } else {\r
 249 this.send_code (18, this.bl_tree);\r
 250 this.send_bits (count - 11, 7);\r
 251 }count = 0;\r
 252 prevlen = curlen;\r
 253 if (nextlen == 0) {\r
 254 max_count = 138;\r
 255 min_count = 3;\r
 256 } else if (curlen == nextlen) {\r
 257 max_count = 6;\r
 258 min_count = 3;\r
 259 } else {\r
 260 max_count = 7;\r
 261 min_count = 4;\r
 262 }}\r
 263 }, "~A,~N");\r
 264 Clazz.defineMethod (c$, "put_byte", \r
 265 function (p, start, len) {\r
 266 System.arraycopy (p, start, this.pending_buf, this.pending, len);\r
 267 this.pending += len;\r
 268 }, "~A,~N,~N");\r
 269 Clazz.defineMethod (c$, "put_byteB", \r
 270 function (c) {\r
 271 {\r
 272 this.pending_buf[this.pending++] = c&0xff;\r
 273 }}, "~N");\r
 274 Clazz.defineMethod (c$, "put_short", \r
 275 function (w) {\r
 276 this.put_byteB ((w));\r
 277 this.put_byteB ((w >>> 8));\r
 278 }, "~N");\r
 279 Clazz.defineMethod (c$, "putShortMSB", \r
 280 function (b) {\r
 281 this.put_byteB ((b >> 8));\r
 282 this.put_byteB ((b));\r
 283 }, "~N");\r
 284 Clazz.defineMethod (c$, "send_code", \r
 285 function (c, tree) {\r
 286 var c2 = c * 2;\r
 287 this.send_bits ((tree[c2] & 0xffff), (tree[c2 + 1] & 0xffff));\r
 288 }, "~N,~A");\r
 289 Clazz.defineMethod (c$, "send_bits", \r
 290 function (value, length) {\r
 291 var len = length;\r
 292 if (this.bi_valid > 16 - len) {\r
 293 var val = value;\r
 294 this.bi_buf |= ((val << this.bi_valid) & 0xffff);\r
 295 this.put_short (this.bi_buf);\r
 296 this.bi_buf = ((val >>> (16 - this.bi_valid)) & 0xffff);\r
 297 this.bi_valid += len - 16;\r
 298 } else {\r
 299 this.bi_buf |= (((value) << this.bi_valid) & 0xffff);\r
 300 this.bi_valid += len;\r
 301 }}, "~N,~N");\r
 302 Clazz.defineMethod (c$, "_tr_align", \r
 303 function () {\r
 304 this.send_bits (2, 3);\r
 305 this.send_code (256, JU.StaticTree.static_ltree);\r
 306 this.bi_flush ();\r
 307 if (1 + this.last_eob_len + 10 - this.bi_valid < 9) {\r
 308 this.send_bits (2, 3);\r
 309 this.send_code (256, JU.StaticTree.static_ltree);\r
 310 this.bi_flush ();\r
 311 }this.last_eob_len = 7;\r
 312 });\r
 313 Clazz.defineMethod (c$, "_tr_tally", \r
 314 function (dist, lc) {\r
 315 this.pending_buf[this.d_buf + this.last_lit * 2] = (dist >>> 8);\r
 316 this.pending_buf[this.d_buf + this.last_lit * 2 + 1] = dist;\r
 317 this.pending_buf[this.l_buf + this.last_lit] = lc;\r
 318 this.last_lit++;\r
 319 if (dist == 0) {\r
 320 this.dyn_ltree[lc * 2]++;\r
 321 } else {\r
 322 this.matches++;\r
 323 dist--;\r
 324 this.dyn_ltree[(JU.Tree._length_code[lc] + 256 + 1) * 2]++;\r
 325 this.dyn_dtree[JU.Tree.d_code (dist) * 2]++;\r
 326 }if ((this.last_lit & 0x1fff) == 0 && this.level > 2) {\r
 327 var out_length = this.last_lit * 8;\r
 328 var in_length = this.strstart - this.block_start;\r
 329 var dcode;\r
 330 for (dcode = 0; dcode < 30; dcode++) {\r
 331 out_length += this.dyn_dtree[dcode * 2] * (5 + JU.Tree.extra_dbits[dcode]);\r
 332 }\r
 333 out_length >>>= 3;\r
 334 if ((this.matches < (Clazz.doubleToInt (this.last_lit / 2))) && out_length < Clazz.doubleToInt (in_length / 2)) return true;\r
 335 }return (this.last_lit == this.lit_bufsize - 1);\r
 336 }, "~N,~N");\r
 337 Clazz.defineMethod (c$, "compress_block", \r
 338 function (ltree, dtree) {\r
 339 var dist;\r
 340 var lc;\r
 341 var lx = 0;\r
 342 var code;\r
 343 var extra;\r
 344 if (this.last_lit != 0) {\r
 345 do {\r
 346 dist = ((this.pending_buf[this.d_buf + lx * 2] << 8) & 0xff00) | (this.pending_buf[this.d_buf + lx * 2 + 1] & 0xff);\r
 347 lc = (this.pending_buf[this.l_buf + lx]) & 0xff;\r
 348 lx++;\r
 349 if (dist == 0) {\r
 350 this.send_code (lc, ltree);\r
 351 } else {\r
 352 code = JU.Tree._length_code[lc];\r
 353 this.send_code (code + 256 + 1, ltree);\r
 354 extra = JU.Tree.extra_lbits[code];\r
 355 if (extra != 0) {\r
 356 lc -= JU.Tree.base_length[code];\r
 357 this.send_bits (lc, extra);\r
 358 }dist--;\r
 359 code = JU.Tree.d_code (dist);\r
 360 this.send_code (code, dtree);\r
 361 extra = JU.Tree.extra_dbits[code];\r
 362 if (extra != 0) {\r
 363 dist -= JU.Tree.base_dist[code];\r
 364 this.send_bits (dist, extra);\r
 365 }}} while (lx < this.last_lit);\r
 366 }this.send_code (256, ltree);\r
 367 this.last_eob_len = ltree[513];\r
 368 }, "~A,~A");\r
 369 Clazz.defineMethod (c$, "set_data_type", \r
 370 function () {\r
 371 var n = 0;\r
 372 var ascii_freq = 0;\r
 373 var bin_freq = 0;\r
 374 while (n < 7) {\r
 375 bin_freq += this.dyn_ltree[n * 2];\r
 376 n++;\r
 377 }\r
 378 while (n < 128) {\r
 379 ascii_freq += this.dyn_ltree[n * 2];\r
 380 n++;\r
 381 }\r
 382 while (n < 256) {\r
 383 bin_freq += this.dyn_ltree[n * 2];\r
 384 n++;\r
 385 }\r
 386 this.data_type = (bin_freq > (ascii_freq >>> 2) ? 0 : 1);\r
 387 });\r
 388 Clazz.defineMethod (c$, "bi_flush", \r
 389 function () {\r
 390 if (this.bi_valid == 16) {\r
 391 this.put_short (this.bi_buf);\r
 392 this.bi_buf = 0;\r
 393 this.bi_valid = 0;\r
 394 } else if (this.bi_valid >= 8) {\r
 395 this.put_byteB (this.bi_buf);\r
 396 this.bi_buf >>>= 8;\r
 397 this.bi_valid -= 8;\r
 398 }});\r
 399 Clazz.defineMethod (c$, "bi_windup", \r
 400 function () {\r
 401 if (this.bi_valid > 8) {\r
 402 this.put_short (this.bi_buf);\r
 403 } else if (this.bi_valid > 0) {\r
 404 this.put_byteB (this.bi_buf);\r
 405 }this.bi_buf = 0;\r
 406 this.bi_valid = 0;\r
 407 });\r
 408 Clazz.defineMethod (c$, "copy_block", \r
 409 function (buf, len, header) {\r
 410 this.bi_windup ();\r
 411 this.last_eob_len = 8;\r
 412 if (header) {\r
 413 this.put_short (len);\r
 414 this.put_short (~len);\r
 415 }this.put_byte (this.window, buf, len);\r
 416 }, "~N,~N,~B");\r
 417 Clazz.defineMethod (c$, "flush_block_only", \r
 418 function (eof) {\r
 419 this._tr_flush_block (this.block_start >= 0 ? this.block_start : -1, this.strstart - this.block_start, eof);\r
 420 this.block_start = this.strstart;\r
 421 this.strm.flush_pending ();\r
 422 }, "~B");\r
 423 Clazz.defineMethod (c$, "deflate_stored", \r
 424 function (flush) {\r
 425 var max_block_size = 0xffff;\r
 426 var max_start;\r
 427 if (max_block_size > this.pending_buf_size - 5) {\r
 428 max_block_size = this.pending_buf_size - 5;\r
 429 }while (true) {\r
 430 if (this.lookahead <= 1) {\r
 431 this.fill_window ();\r
 432 if (this.lookahead == 0 && flush == 0) return 0;\r
 433 if (this.lookahead == 0) break;\r
 434 }this.strstart += this.lookahead;\r
 435 this.lookahead = 0;\r
 436 max_start = this.block_start + max_block_size;\r
 437 if (this.strstart == 0 || this.strstart >= max_start) {\r
 438 this.lookahead = (this.strstart - max_start);\r
 439 this.strstart = max_start;\r
 440 this.flush_block_only (false);\r
 441 if (this.strm.avail_out == 0) return 0;\r
 442 }if (this.strstart - this.block_start >= this.w_size - 262) {\r
 443 this.flush_block_only (false);\r
 444 if (this.strm.avail_out == 0) return 0;\r
 445 }}\r
 446 this.flush_block_only (flush == 4);\r
 447 if (this.strm.avail_out == 0) return (flush == 4) ? 2 : 0;\r
 448 return flush == 4 ? 3 : 1;\r
 449 }, "~N");\r
 450 Clazz.defineMethod (c$, "_tr_stored_block", \r
 451 function (buf, stored_len, eof) {\r
 452 this.send_bits ((0) + (eof ? 1 : 0), 3);\r
 453 this.copy_block (buf, stored_len, true);\r
 454 }, "~N,~N,~B");\r
 455 Clazz.defineMethod (c$, "_tr_flush_block", \r
 456 function (buf, stored_len, eof) {\r
 457 var opt_lenb;\r
 458 var static_lenb;\r
 459 var max_blindex = 0;\r
 460 if (this.level > 0) {\r
 461 if (this.data_type == 2) this.set_data_type ();\r
 462 this.l_desc.build_tree (this);\r
 463 this.d_desc.build_tree (this);\r
 464 max_blindex = this.build_bl_tree ();\r
 465 opt_lenb = (this.opt_len + 3 + 7) >>> 3;\r
 466 static_lenb = (this.static_len + 3 + 7) >>> 3;\r
 467 if (static_lenb <= opt_lenb) opt_lenb = static_lenb;\r
 468 } else {\r
 469 opt_lenb = static_lenb = stored_len + 5;\r
 470 }if (stored_len + 4 <= opt_lenb && buf != -1) {\r
 471 this._tr_stored_block (buf, stored_len, eof);\r
 472 } else if (static_lenb == opt_lenb) {\r
 473 this.send_bits ((2) + (eof ? 1 : 0), 3);\r
 474 this.compress_block (JU.StaticTree.static_ltree, JU.StaticTree.static_dtree);\r
 475 } else {\r
 476 this.send_bits ((4) + (eof ? 1 : 0), 3);\r
 477 this.send_all_trees (this.l_desc.max_code + 1, this.d_desc.max_code + 1, max_blindex + 1);\r
 478 this.compress_block (this.dyn_ltree, this.dyn_dtree);\r
 479 }this.init_block ();\r
 480 if (eof) {\r
 481 this.bi_windup ();\r
 482 }}, "~N,~N,~B");\r
 483 Clazz.defineMethod (c$, "fill_window", \r
 484 function () {\r
 485 var n;\r
 486 var m;\r
 487 var p;\r
 488 var more;\r
 489 do {\r
 490 more = (this.window_size - this.lookahead - this.strstart);\r
 491 if (more == 0 && this.strstart == 0 && this.lookahead == 0) {\r
 492 more = this.w_size;\r
 493 } else if (more == -1) {\r
 494 more--;\r
 495 } else if (this.strstart >= this.w_size + this.w_size - 262) {\r
 496 System.arraycopy (this.window, this.w_size, this.window, 0, this.w_size);\r
 497 this.match_start -= this.w_size;\r
 498 this.strstart -= this.w_size;\r
 499 this.block_start -= this.w_size;\r
 500 n = this.hash_size;\r
 501 p = n;\r
 502 do {\r
 503 m = (this.head[--p] & 0xffff);\r
 504 this.head[p] = (m >= this.w_size ? (m - this.w_size) : 0);\r
 505 } while (--n != 0);\r
 506 n = this.w_size;\r
 507 p = n;\r
 508 do {\r
 509 m = (this.prev[--p] & 0xffff);\r
 510 this.prev[p] = (m >= this.w_size ? (m - this.w_size) : 0);\r
 511 } while (--n != 0);\r
 512 more += this.w_size;\r
 513 }if (this.strm.avail_in == 0) return;\r
 514 n = this.strm.read_buf (this.window, this.strstart + this.lookahead, more);\r
 515 this.lookahead += n;\r
 516 if (this.lookahead >= 3) {\r
 517 this.ins_h = this.window[this.strstart] & 0xff;\r
 518 this.ins_h = (((this.ins_h) << this.hash_shift) ^ (this.window[this.strstart + 1] & 0xff)) & this.hash_mask;\r
 519 }} while (this.lookahead < 262 && this.strm.avail_in != 0);\r
 520 });\r
 521 Clazz.defineMethod (c$, "deflate_fast", \r
 522 function (flush) {\r
 523 var hash_head = 0;\r
 524 var bflush;\r
 525 while (true) {\r
 526 if (this.lookahead < 262) {\r
 527 this.fill_window ();\r
 528 if (this.lookahead < 262 && flush == 0) {\r
 529 return 0;\r
 530 }if (this.lookahead == 0) break;\r
 531 }if (this.lookahead >= 3) {\r
 532 this.ins_h = (((this.ins_h) << this.hash_shift) ^ (this.window[(this.strstart) + (2)] & 0xff)) & this.hash_mask;\r
 533 hash_head = (this.head[this.ins_h] & 0xffff);\r
 534 this.prev[this.strstart & this.w_mask] = this.head[this.ins_h];\r
 535 this.head[this.ins_h] = this.strstart;\r
 536 }if (hash_head != 0 && ((this.strstart - hash_head) & 0xffff) <= this.w_size - 262) {\r
 537 if (this.strategy != 2) {\r
 538 this.match_length = this.longest_match (hash_head);\r
 539 }}if (this.match_length >= 3) {\r
 540 bflush = this._tr_tally (this.strstart - this.match_start, this.match_length - 3);\r
 541 this.lookahead -= this.match_length;\r
 542 if (this.match_length <= this.max_lazy_match && this.lookahead >= 3) {\r
 543 this.match_length--;\r
 544 do {\r
 545 this.strstart++;\r
 546 this.ins_h = ((this.ins_h << this.hash_shift) ^ (this.window[(this.strstart) + (2)] & 0xff)) & this.hash_mask;\r
 547 hash_head = (this.head[this.ins_h] & 0xffff);\r
 548 this.prev[this.strstart & this.w_mask] = this.head[this.ins_h];\r
 549 this.head[this.ins_h] = this.strstart;\r
 550 } while (--this.match_length != 0);\r
 551 this.strstart++;\r
 552 } else {\r
 553 this.strstart += this.match_length;\r
 554 this.match_length = 0;\r
 555 this.ins_h = this.window[this.strstart] & 0xff;\r
 556 this.ins_h = (((this.ins_h) << this.hash_shift) ^ (this.window[this.strstart + 1] & 0xff)) & this.hash_mask;\r
 557 }} else {\r
 558 bflush = this._tr_tally (0, this.window[this.strstart] & 0xff);\r
 559 this.lookahead--;\r
 560 this.strstart++;\r
 561 }if (bflush) {\r
 562 this.flush_block_only (false);\r
 563 if (this.strm.avail_out == 0) return 0;\r
 564 }}\r
 565 this.flush_block_only (flush == 4);\r
 566 if (this.strm.avail_out == 0) {\r
 567 if (flush == 4) return 2;\r
 568 return 0;\r
 569 }return flush == 4 ? 3 : 1;\r
 570 }, "~N");\r
 571 Clazz.defineMethod (c$, "deflate_slow", \r
 572 function (flush) {\r
 573 var hash_head = 0;\r
 574 var bflush;\r
 575 while (true) {\r
 576 if (this.lookahead < 262) {\r
 577 this.fill_window ();\r
 578 if (this.lookahead < 262 && flush == 0) {\r
 579 return 0;\r
 580 }if (this.lookahead == 0) break;\r
 581 }if (this.lookahead >= 3) {\r
 582 this.ins_h = (((this.ins_h) << this.hash_shift) ^ (this.window[(this.strstart) + (2)] & 0xff)) & this.hash_mask;\r
 583 hash_head = (this.head[this.ins_h] & 0xffff);\r
 584 this.prev[this.strstart & this.w_mask] = this.head[this.ins_h];\r
 585 this.head[this.ins_h] = this.strstart;\r
 586 }this.prev_length = this.match_length;\r
 587 this.prev_match = this.match_start;\r
 588 this.match_length = 2;\r
 589 if (hash_head != 0 && this.prev_length < this.max_lazy_match && ((this.strstart - hash_head) & 0xffff) <= this.w_size - 262) {\r
 590 if (this.strategy != 2) {\r
 591 this.match_length = this.longest_match (hash_head);\r
 592 }if (this.match_length <= 5 && (this.strategy == 1 || (this.match_length == 3 && this.strstart - this.match_start > 4096))) {\r
 593 this.match_length = 2;\r
 594 }}if (this.prev_length >= 3 && this.match_length <= this.prev_length) {\r
 595 var max_insert = this.strstart + this.lookahead - 3;\r
 596 bflush = this._tr_tally (this.strstart - 1 - this.prev_match, this.prev_length - 3);\r
 597 this.lookahead -= this.prev_length - 1;\r
 598 this.prev_length -= 2;\r
 599 do {\r
 600 if (++this.strstart <= max_insert) {\r
 601 this.ins_h = (((this.ins_h) << this.hash_shift) ^ (this.window[(this.strstart) + (2)] & 0xff)) & this.hash_mask;\r
 602 hash_head = (this.head[this.ins_h] & 0xffff);\r
 603 this.prev[this.strstart & this.w_mask] = this.head[this.ins_h];\r
 604 this.head[this.ins_h] = this.strstart;\r
 605 }} while (--this.prev_length != 0);\r
 606 this.match_available = 0;\r
 607 this.match_length = 2;\r
 608 this.strstart++;\r
 609 if (bflush) {\r
 610 this.flush_block_only (false);\r
 611 if (this.strm.avail_out == 0) return 0;\r
 612 }} else if (this.match_available != 0) {\r
 613 bflush = this._tr_tally (0, this.window[this.strstart - 1] & 0xff);\r
 614 if (bflush) {\r
 615 this.flush_block_only (false);\r
 616 }this.strstart++;\r
 617 this.lookahead--;\r
 618 if (this.strm.avail_out == 0) return 0;\r
 619 } else {\r
 620 this.match_available = 1;\r
 621 this.strstart++;\r
 622 this.lookahead--;\r
 623 }}\r
 624 if (this.match_available != 0) {\r
 625 bflush = this._tr_tally (0, this.window[this.strstart - 1] & 0xff);\r
 626 this.match_available = 0;\r
 627 }this.flush_block_only (flush == 4);\r
 628 if (this.strm.avail_out == 0) {\r
 629 if (flush == 4) return 2;\r
 630 return 0;\r
 631 }return flush == 4 ? 3 : 1;\r
 632 }, "~N");\r
 633 Clazz.defineMethod (c$, "longest_match", \r
 634 function (cur_match) {\r
 635 var chain_length = this.max_chain_length;\r
 636 var scan = this.strstart;\r
 637 var match;\r
 638 var len;\r
 639 var best_len = this.prev_length;\r
 640 var limit = this.strstart > (this.w_size - 262) ? this.strstart - (this.w_size - 262) : 0;\r
 641 var nice_match = this.nice_match;\r
 642 var wmask = this.w_mask;\r
 643 var strend = this.strstart + 258;\r
 644 var scan_end1 = this.window[scan + best_len - 1];\r
 645 var scan_end = this.window[scan + best_len];\r
 646 if (this.prev_length >= this.good_match) {\r
 647 chain_length >>= 2;\r
 648 }if (nice_match > this.lookahead) nice_match = this.lookahead;\r
 649 do {\r
 650 match = cur_match;\r
 651 if (this.window[match + best_len] != scan_end || this.window[match + best_len - 1] != scan_end1 || this.window[match] != this.window[scan] || this.window[++match] != this.window[scan + 1]) continue;\r
 652 scan += 2;\r
 653 match++;\r
 654 do {\r
 655 } while (this.window[++scan] == this.window[++match] && this.window[++scan] == this.window[++match] && this.window[++scan] == this.window[++match] && this.window[++scan] == this.window[++match] && this.window[++scan] == this.window[++match] && this.window[++scan] == this.window[++match] && this.window[++scan] == this.window[++match] && this.window[++scan] == this.window[++match] && scan < strend);\r
 656 len = 258 - (strend - scan);\r
 657 scan = strend - 258;\r
 658 if (len > best_len) {\r
 659 this.match_start = cur_match;\r
 660 best_len = len;\r
 661 if (len >= nice_match) break;\r
 662 scan_end1 = this.window[scan + best_len - 1];\r
 663 scan_end = this.window[scan + best_len];\r
 664 }} while ((cur_match = (this.prev[cur_match & wmask] & 0xffff)) > limit && --chain_length != 0);\r
 665 if (best_len <= this.lookahead) return best_len;\r
 666 return this.lookahead;\r
 667 }, "~N");\r
 668 Clazz.defineMethod (c$, "deflateInit5", \r
 669  function (level, method, windowBits, memLevel, strategy) {\r
 670 var wrap = 1;\r
 671 this.strm.msg = null;\r
 672 if (level == -1) level = 6;\r
 673 if (windowBits < 0) {\r
 674 wrap = 0;\r
 675 windowBits = -windowBits;\r
 676 } else if (windowBits > 15) {\r
 677 wrap = 2;\r
 678 windowBits -= 16;\r
 679 this.strm.checksum =  new JU.CRC32 ();\r
 680 }if (memLevel < 1 || memLevel > 9 || method != 8 || windowBits < 9 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > 2) {\r
 681 return -2;\r
 682 }this.strm.dstate = this;\r
 683 this.wrap = wrap;\r
 684 this.w_bits = windowBits;\r
 685 this.w_size = 1 << this.w_bits;\r
 686 this.w_mask = this.w_size - 1;\r
 687 this.hash_bits = memLevel + 7;\r
 688 this.hash_size = 1 << this.hash_bits;\r
 689 this.hash_mask = this.hash_size - 1;\r
 690 this.hash_shift = (Clazz.doubleToInt ((this.hash_bits + 3 - 1) / 3));\r
 691 this.window =  Clazz.newByteArray (this.w_size * 2, 0);\r
 692 this.prev =  Clazz.newShortArray (this.w_size, 0);\r
 693 this.head =  Clazz.newShortArray (this.hash_size, 0);\r
 694 this.lit_bufsize = 1 << (memLevel + 6);\r
 695 this.pending_buf =  Clazz.newByteArray (this.lit_bufsize * 4, 0);\r
 696 this.pending_buf_size = this.lit_bufsize * 4;\r
 697 this.d_buf = Clazz.doubleToInt (this.lit_bufsize / 2);\r
 698 this.l_buf = (3) * this.lit_bufsize;\r
 699 this.level = level;\r
 700 this.strategy = strategy;\r
 701 this.method = method;\r
 702 return this.deflateReset ();\r
 703 }, "~N,~N,~N,~N,~N");\r
 704 Clazz.defineMethod (c$, "deflateReset", \r
 705 function () {\r
 706 this.strm.total_in = this.strm.total_out = 0;\r
 707 this.strm.msg = null;\r
 708 this.strm.data_type = 2;\r
 709 this.pending = 0;\r
 710 this.pending_out = 0;\r
 711 if (this.wrap < 0) {\r
 712 this.wrap = -this.wrap;\r
 713 }this.status = (this.wrap == 0) ? 113 : 42;\r
 714 this.strm.checksum.reset ();\r
 715 this.last_flush = 0;\r
 716 this.tr_init ();\r
 717 this.lm_init ();\r
 718 return 0;\r
 719 });\r
 720 Clazz.defineMethod (c$, "deflateEnd", \r
 721 function () {\r
 722 if (this.status != 42 && this.status != 113 && this.status != 666) {\r
 723 return -2;\r
 724 }this.pending_buf = null;\r
 725 this.head = null;\r
 726 this.prev = null;\r
 727 this.window = null;\r
 728 return this.status == 113 ? -3 : 0;\r
 729 });\r
 730 Clazz.defineMethod (c$, "deflateParams", \r
 731 function (_level, _strategy) {\r
 732 var err = 0;\r
 733 if (_level == -1) {\r
 734 _level = 6;\r
 735 }if (_level < 0 || _level > 9 || _strategy < 0 || _strategy > 2) {\r
 736 return -2;\r
 737 }if (JU.Deflate.config_table[this.level].func != JU.Deflate.config_table[_level].func && this.strm.total_in != 0) {\r
 738 err = this.strm.deflate (1);\r
 739 }if (this.level != _level) {\r
 740 this.level = _level;\r
 741 this.max_lazy_match = JU.Deflate.config_table[this.level].max_lazy;\r
 742 this.good_match = JU.Deflate.config_table[this.level].good_length;\r
 743 this.nice_match = JU.Deflate.config_table[this.level].nice_length;\r
 744 this.max_chain_length = JU.Deflate.config_table[this.level].max_chain;\r
 745 }this.strategy = _strategy;\r
 746 return err;\r
 747 }, "~N,~N");\r
 748 Clazz.defineMethod (c$, "deflateSetDictionary", \r
 749 function (dictionary, dictLength) {\r
 750 var length = dictLength;\r
 751 var index = 0;\r
 752 if (dictionary == null || this.status != 42) return -2;\r
 753 this.strm.checksum.update (dictionary, 0, dictLength);\r
 754 if (length < 3) return 0;\r
 755 if (length > this.w_size - 262) {\r
 756 length = this.w_size - 262;\r
 757 index = dictLength - length;\r
 758 }System.arraycopy (dictionary, index, this.window, 0, length);\r
 759 this.strstart = length;\r
 760 this.block_start = length;\r
 761 this.ins_h = this.window[0] & 0xff;\r
 762 this.ins_h = (((this.ins_h) << this.hash_shift) ^ (this.window[1] & 0xff)) & this.hash_mask;\r
 763 for (var n = 0; n <= length - 3; n++) {\r
 764 this.ins_h = (((this.ins_h) << this.hash_shift) ^ (this.window[(n) + (2)] & 0xff)) & this.hash_mask;\r
 765 this.prev[n & this.w_mask] = this.head[this.ins_h];\r
 766 this.head[this.ins_h] = n;\r
 767 }\r
 768 return 0;\r
 769 }, "~A,~N");\r
 770 Clazz.defineMethod (c$, "deflate", \r
 771 function (flush) {\r
 772 var old_flush;\r
 773 if (flush > 4 || flush < 0) {\r
 774 return -2;\r
 775 }if (this.strm.next_out == null || (this.strm.next_in == null && this.strm.avail_in != 0) || (this.status == 666 && flush != 4)) {\r
 776 this.strm.msg = JU.Deflate.z_errmsg[4];\r
 777 return -2;\r
 778 }if (this.strm.avail_out == 0) {\r
 779 this.strm.msg = JU.Deflate.z_errmsg[7];\r
 780 return -5;\r
 781 }old_flush = this.last_flush;\r
 782 this.last_flush = flush;\r
 783 if (this.status == 42) {\r
 784 if (this.wrap == 2) {\r
 785 this.getGZIPHeader ().put (this);\r
 786 this.status = 113;\r
 787 this.strm.checksum.reset ();\r
 788 } else {\r
 789 var header = (8 + ((this.w_bits - 8) << 4)) << 8;\r
 790 var level_flags = ((this.level - 1) & 0xff) >> 1;\r
 791 if (level_flags > 3) level_flags = 3;\r
 792 header |= (level_flags << 6);\r
 793 if (this.strstart != 0) header |= 32;\r
 794 header += 31 - (header % 31);\r
 795 this.status = 113;\r
 796 this.putShortMSB (header);\r
 797 if (this.strstart != 0) {\r
 798 var adler = this.strm.checksum.getValue ();\r
 799 this.putShortMSB ((adler >>> 16));\r
 800 this.putShortMSB ((adler & 0xffff));\r
 801 }this.strm.checksum.reset ();\r
 802 }}if (this.pending != 0) {\r
 803 this.strm.flush_pending ();\r
 804 if (this.strm.avail_out == 0) {\r
 805 this.last_flush = -1;\r
 806 return 0;\r
 807 }} else if (this.strm.avail_in == 0 && flush <= old_flush && flush != 4) {\r
 808 this.strm.msg = JU.Deflate.z_errmsg[7];\r
 809 return -5;\r
 810 }if (this.status == 666 && this.strm.avail_in != 0) {\r
 811 this.strm.msg = JU.Deflate.z_errmsg[7];\r
 812 return -5;\r
 813 }if (this.strm.avail_in != 0 || this.lookahead != 0 || (flush != 0 && this.status != 666)) {\r
 814 var bstate = -1;\r
 815 switch (JU.Deflate.config_table[this.level].func) {\r
 816 case 0:\r
 817 bstate = this.deflate_stored (flush);\r
 818 break;\r
 819 case 1:\r
 820 bstate = this.deflate_fast (flush);\r
 821 break;\r
 822 case 2:\r
 823 bstate = this.deflate_slow (flush);\r
 824 break;\r
 825 default:\r
 826 }\r
 827 if (bstate == 2 || bstate == 3) {\r
 828 this.status = 666;\r
 829 }if (bstate == 0 || bstate == 2) {\r
 830 if (this.strm.avail_out == 0) {\r
 831 this.last_flush = -1;\r
 832 }return 0;\r
 833 }if (bstate == 1) {\r
 834 if (flush == 1) {\r
 835 this._tr_align ();\r
 836 } else {\r
 837 this._tr_stored_block (0, 0, false);\r
 838 if (flush == 3) {\r
 839 for (var i = 0; i < this.hash_size; i++) this.head[i] = 0;\r
 840 \r
 841 }}this.strm.flush_pending ();\r
 842 if (this.strm.avail_out == 0) {\r
 843 this.last_flush = -1;\r
 844 return 0;\r
 845 }}}if (flush != 4) return 0;\r
 846 if (this.wrap <= 0) return 1;\r
 847 if (this.wrap == 2) {\r
 848 var adler = this.strm.checksum.getValue ();\r
 849 this.put_byteB ((adler & 0xff));\r
 850 this.put_byteB (((adler >> 8) & 0xff));\r
 851 this.put_byteB (((adler >> 16) & 0xff));\r
 852 this.put_byteB (((adler >> 24) & 0xff));\r
 853 this.put_byteB ((this.strm.total_in & 0xff));\r
 854 this.put_byteB (((this.strm.total_in >> 8) & 0xff));\r
 855 this.put_byteB (((this.strm.total_in >> 16) & 0xff));\r
 856 this.put_byteB (((this.strm.total_in >> 24) & 0xff));\r
 857 this.getGZIPHeader ().setCRC (adler);\r
 858 } else {\r
 859 var adler = this.strm.checksum.getValue ();\r
 860 this.putShortMSB ((adler >>> 16));\r
 861 this.putShortMSB ((adler & 0xffff));\r
 862 }this.strm.flush_pending ();\r
 863 if (this.wrap > 0) this.wrap = -this.wrap;\r
 864 return this.pending != 0 ? 0 : 1;\r
 865 }, "~N");\r
 866 Clazz.defineMethod (c$, "getGZIPHeader", \r
 867 function () {\r
 868 if (this.gheader == null) {\r
 869 this.gheader =  new JU.GZIPHeader ();\r
 870 }return this.gheader;\r
 871 });\r
 872 Clazz.defineMethod (c$, "getBytesRead", \r
 873 function () {\r
 874 return this.strm.total_in;\r
 875 });\r
 876 Clazz.defineMethod (c$, "getBytesWritten", \r
 877 function () {\r
 878 return this.strm.total_out;\r
 879 });\r
 880 Clazz.pu$h(self.c$);\r
 881 c$ = Clazz.decorateAsClass (function () {\r
 882 this.good_length = 0;\r
 883 this.max_lazy = 0;\r
 884 this.nice_length = 0;\r
 885 this.max_chain = 0;\r
 886 this.func = 0;\r
 887 Clazz.instantialize (this, arguments);\r
 888 }, JU.Deflate, "Config");\r
 889 Clazz.makeConstructor (c$, \r
 890 function (a, b, c, d, e) {\r
 891 this.good_length = a;\r
 892 this.max_lazy = b;\r
 893 this.nice_length = c;\r
 894 this.max_chain = d;\r
 895 this.func = e;\r
 896 }, "~N,~N,~N,~N,~N");\r
 897 c$ = Clazz.p0p ();\r
 898 Clazz.defineStatics (c$,\r
 899 "MAX_MEM_LEVEL", 9,\r
 900 "Z_DEFAULT_COMPRESSION", -1,\r
 901 "MAX_WBITS", 15,\r
 902 "DEF_MEM_LEVEL", 8,\r
 903 "STORED", 0,\r
 904 "FAST", 1,\r
 905 "SLOW", 2,\r
 906 "config_table", null);\r
 907 {\r
 908 JU.Deflate.config_table =  new Array (10);\r
 909 JU.Deflate.config_table[0] =  new JU.Deflate.Config (0, 0, 0, 0, 0);\r
 910 JU.Deflate.config_table[1] =  new JU.Deflate.Config (4, 4, 8, 4, 1);\r
 911 JU.Deflate.config_table[2] =  new JU.Deflate.Config (4, 5, 16, 8, 1);\r
 912 JU.Deflate.config_table[3] =  new JU.Deflate.Config (4, 6, 32, 32, 1);\r
 913 JU.Deflate.config_table[4] =  new JU.Deflate.Config (4, 4, 16, 16, 2);\r
 914 JU.Deflate.config_table[5] =  new JU.Deflate.Config (8, 16, 32, 32, 2);\r
 915 JU.Deflate.config_table[6] =  new JU.Deflate.Config (8, 16, 128, 128, 2);\r
 916 JU.Deflate.config_table[7] =  new JU.Deflate.Config (8, 32, 128, 256, 2);\r
 917 JU.Deflate.config_table[8] =  new JU.Deflate.Config (32, 128, 258, 1024, 2);\r
 918 JU.Deflate.config_table[9] =  new JU.Deflate.Config (32, 258, 258, 4096, 2);\r
 919 }Clazz.defineStatics (c$,\r
 920 "z_errmsg",  Clazz.newArray (-1, ["need dictionary", "stream end", "", "file error", "stream error", "data error", "insufficient memory", "buffer error", "incompatible version", ""]),\r
 921 "NeedMore", 0,\r
 922 "BlockDone", 1,\r
 923 "FinishStarted", 2,\r
 924 "FinishDone", 3,\r
 925 "PRESET_DICT", 0x20,\r
 926 "Z_FILTERED", 1,\r
 927 "Z_HUFFMAN_ONLY", 2,\r
 928 "Z_DEFAULT_STRATEGY", 0,\r
 929 "Z_NO_FLUSH", 0,\r
 930 "Z_PARTIAL_FLUSH", 1,\r
 931 "Z_FULL_FLUSH", 3,\r
 932 "Z_FINISH", 4,\r
 933 "Z_OK", 0,\r
 934 "Z_STREAM_END", 1,\r
 935 "Z_NEED_DICT", 2,\r
 936 "Z_STREAM_ERROR", -2,\r
 937 "Z_DATA_ERROR", -3,\r
 938 "Z_BUF_ERROR", -5,\r
 939 "INIT_STATE", 42,\r
 940 "BUSY_STATE", 113,\r
 941 "FINISH_STATE", 666,\r
 942 "Z_DEFLATED", 8,\r
 943 "STORED_BLOCK", 0,\r
 944 "STATIC_TREES", 1,\r
 945 "DYN_TREES", 2,\r
 946 "Z_BINARY", 0,\r
 947 "Z_ASCII", 1,\r
 948 "Z_UNKNOWN", 2,\r
 949 "Buf_size", 16,\r
 950 "REP_3_6", 16,\r
 951 "REPZ_3_10", 17,\r
 952 "REPZ_11_138", 18,\r
 953 "MIN_MATCH", 3,\r
 954 "MAX_MATCH", 258,\r
 955 "MIN_LOOKAHEAD", (262),\r
 956 "MAX_BITS", 15,\r
 957 "D_CODES", 30,\r
 958 "BL_CODES", 19,\r
 959 "LENGTH_CODES", 29,\r
 960 "LITERALS", 256,\r
 961 "L_CODES", (286),\r
 962 "HEAP_SIZE", (573),\r
 963 "END_BLOCK", 256);\r
 964 });\r