00001
00002
00003
00004
00005
00006
00007
00008 (function(){
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 var zip_WSIZE = 32768;
00021 var zip_STORED_BLOCK = 0;
00022 var zip_STATIC_TREES = 1;
00023 var zip_DYN_TREES = 2;
00024
00025
00026 var zip_lbits = 9;
00027 var zip_dbits = 6;
00028 var zip_INBUFSIZ = 32768;
00029 var zip_INBUF_EXTRA = 64;
00030
00031
00032 var zip_slide;
00033 var zip_wp;
00034 var zip_fixed_tl = null;
00035 var zip_fixed_td;
00036 var zip_fixed_bl, fixed_bd;
00037 var zip_bit_buf;
00038 var zip_bit_len;
00039 var zip_method;
00040 var zip_eof;
00041 var zip_copy_leng;
00042 var zip_copy_dist;
00043 var zip_tl, zip_td;
00044 var zip_bl, zip_bd;
00045
00046 var zip_inflate_data;
00047 var zip_inflate_pos;
00048
00049
00050 var zip_MASK_BITS = new Array(
00051 0x0000,
00052 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
00053 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff);
00054
00055 var zip_cplens = new Array(
00056 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
00057 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0);
00058
00059 var zip_cplext = new Array(
00060 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
00061 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99);
00062 var zip_cpdist = new Array(
00063 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
00064 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
00065 8193, 12289, 16385, 24577);
00066 var zip_cpdext = new Array(
00067 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
00068 7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
00069 12, 12, 13, 13);
00070 var zip_border = new Array(
00071 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15);
00072
00073
00074 var zip_HuftList = function() {
00075 this.next = null;
00076 this.list = null;
00077 }
00078
00079 var zip_HuftNode = function() {
00080 this.e = 0;
00081 this.b = 0;
00082
00083
00084 this.n = 0;
00085 this.t = null;
00086 }
00087
00088 var zip_HuftBuild = function(b,
00089 n,
00090 s,
00091 d,
00092 e,
00093 mm ) {
00094
00095 this.BMAX = 16;
00096 this.N_MAX = 288;
00097 this.status = 0;
00098 this.root = null;
00099 this.m = 0;
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109 {
00110 var a;
00111 var c = new Array(this.BMAX+1);
00112 var el;
00113 var f;
00114 var g;
00115 var h;
00116 var i;
00117 var j;
00118 var k;
00119 var lx = new Array(this.BMAX+1);
00120 var p;
00121 var pidx;
00122 var q;
00123 var r = new zip_HuftNode();
00124 var u = new Array(this.BMAX);
00125 var v = new Array(this.N_MAX);
00126 var w;
00127 var x = new Array(this.BMAX+1);
00128 var xp;
00129 var y;
00130 var z;
00131 var o;
00132 var tail;
00133
00134 tail = this.root = null;
00135 for (i = 0; i < c.length; ++i)
00136 c[i] = 0;
00137 for (i = 0; i < lx.length; ++i)
00138 lx[i] = 0;
00139 for (i = 0; i < u.length; ++i)
00140 u[i] = null;
00141 for (i = 0; i < v.length; ++i)
00142 v[i] = 0;
00143 for (i = 0; i < x.length; ++i)
00144 x[i] = 0;
00145
00146
00147 el = n > 256 ? b[256] : this.BMAX;
00148 p = b; pidx = 0;
00149 i = n;
00150 do {
00151 c[p[pidx]]++;
00152 pidx++;
00153 } while (--i > 0);
00154
00155 if (c[0] == n) {
00156 this.root = null;
00157 this.m = 0;
00158 this.status = 0;
00159 return;
00160 }
00161
00162
00163 for (j = 1; j <= this.BMAX; ++j)
00164 if (c[j] != 0)
00165 break;
00166 k = j;
00167 if (mm < j)
00168 mm = j;
00169 for (i = this.BMAX; i != 0; i--)
00170 if (c[i] != 0)
00171 break;
00172 g = i;
00173 if (mm > i)
00174 mm = i;
00175
00176
00177 for (y = 1 << j; j < i; ++j, y <<= 1) {
00178 if ((y -= c[j]) < 0) {
00179 this.status = 2;
00180 this.m = mm;
00181 return;
00182 }
00183 }
00184 if ((y -= c[i]) < 0) {
00185 this.status = 2;
00186 this.m = mm;
00187 return;
00188 }
00189 c[i] += y;
00190
00191
00192 x[1] = j = 0;
00193 p = c;
00194 pidx = 1;
00195 xp = 2;
00196 while (--i > 0)
00197 x[xp++] = (j += p[pidx++]);
00198
00199
00200 p = b; pidx = 0;
00201 i = 0;
00202 do {
00203 if ((j = p[pidx++]) != 0)
00204 v[x[j]++] = i;
00205 } while (++i < n);
00206 n = x[g];
00207
00208
00209 x[0] = i = 0;
00210 p = v; pidx = 0;
00211 h = -1;
00212 w = lx[0] = 0;
00213 q = null;
00214 z = 0;
00215
00216
00217 for (; k <= g; ++k) {
00218 a = c[k];
00219 while (a-- > 0) {
00220
00221
00222 while (k > w + lx[1 + h]) {
00223 w += lx[1 + h];
00224 h++;
00225
00226
00227 z = (z = g - w) > mm ? mm : z;
00228 if ((f = 1 << (j = k - w)) > a + 1) {
00229
00230 f -= a + 1;
00231 xp = k;
00232 while (++j < z) {
00233 if ((f <<= 1) <= c[++xp])
00234 break;
00235 f -= c[xp];
00236 }
00237 }
00238 if (w + j > el && w < el)
00239 j = el - w;
00240 z = 1 << j;
00241 lx[1 + h] = j;
00242
00243
00244 q = new Array(z);
00245 for (o = 0; o < z; o++) {
00246 q[o] = new zip_HuftNode();
00247 }
00248
00249 if (tail == null)
00250 tail = this.root = new zip_HuftList();
00251 else
00252 tail = tail.next = new zip_HuftList();
00253 tail.next = null;
00254 tail.list = q;
00255 u[h] = q;
00256
00257
00258 if (h > 0) {
00259 x[h] = i;
00260 r.b = lx[h];
00261 r.e = 16 + j;
00262 r.t = q;
00263 j = (i & ((1 << w) - 1)) >> (w - lx[h]);
00264 u[h-1][j].e = r.e;
00265 u[h-1][j].b = r.b;
00266 u[h-1][j].n = r.n;
00267 u[h-1][j].t = r.t;
00268 }
00269 }
00270
00271
00272 r.b = k - w;
00273 if (pidx >= n)
00274 r.e = 99;
00275 else if (p[pidx] < s) {
00276 r.e = (p[pidx] < 256 ? 16 : 15);
00277 r.n = p[pidx++];
00278 } else {
00279 r.e = e[p[pidx] - s];
00280 r.n = d[p[pidx++] - s];
00281 }
00282
00283
00284 f = 1 << (k - w);
00285 for (j = i >> w; j < z; j += f) {
00286 q[j].e = r.e;
00287 q[j].b = r.b;
00288 q[j].n = r.n;
00289 q[j].t = r.t;
00290 }
00291
00292
00293 for (j = 1 << (k - 1); (i & j) != 0; j >>= 1)
00294 i ^= j;
00295 i ^= j;
00296
00297
00298 while ((i & ((1 << w) - 1)) != x[h]) {
00299 w -= lx[h];
00300 h--;
00301 }
00302 }
00303 }
00304
00305
00306 this.m = lx[1];
00307
00308
00309 this.status = ((y != 0 && g != 1) ? 1 : 0);
00310 }
00311
00312 }
00313
00314
00315
00316 var zip_GET_BYTE = function() {
00317 if (zip_inflate_data.length == zip_inflate_pos)
00318 return -1;
00319 return zip_inflate_data.charCodeAt(zip_inflate_pos++) & 0xff;
00320 }
00321 var zip_NEEDBITS_DFLT = function(n) {
00322 while (zip_bit_len < n) {
00323 zip_bit_buf |= zip_GET_BYTE() << zip_bit_len;
00324 zip_bit_len += 8;
00325 }
00326 }
00327
00328 var zip_NEEDBITS_ARR = function(n) {
00329 while (zip_bit_len < n) {
00330 if (zip_inflate_pos < zip_inflate_data.byteLength)
00331 zip_bit_buf |= zip_inflate_data[zip_inflate_pos++] << zip_bit_len;
00332 zip_bit_len += 8;
00333 }
00334 }
00335
00336 var zip_NEEDBITS = zip_NEEDBITS_DFLT;
00337
00338 var zip_GETBITS = function(n) {
00339 return zip_bit_buf & zip_MASK_BITS[n];
00340 }
00341
00342 var zip_DUMPBITS = function(n) {
00343 zip_bit_buf >>= n;
00344 zip_bit_len -= n;
00345 }
00346
00347 var zip_inflate_codes = function(buff, off, size) {
00348
00349
00350 var e;
00351 var t;
00352 var n;
00353
00354 if (size == 0)
00355 return 0;
00356
00357
00358 n = 0;
00359 for (;;) {
00360 zip_NEEDBITS(zip_bl);
00361 t = zip_tl.list[zip_GETBITS(zip_bl)];
00362 e = t.e;
00363 while (e > 16) {
00364 if (e == 99)
00365 return -1;
00366 zip_DUMPBITS(t.b);
00367 e -= 16;
00368 zip_NEEDBITS(e);
00369 t = t.t[zip_GETBITS(e)];
00370 e = t.e;
00371 }
00372 zip_DUMPBITS(t.b);
00373
00374 if (e == 16) {
00375 zip_wp &= zip_WSIZE - 1;
00376 buff[off + n++] = zip_slide[zip_wp++] = t.n;
00377 if (n == size)
00378 return size;
00379 continue;
00380 }
00381
00382
00383 if (e == 15)
00384 break;
00385
00386
00387
00388
00389 zip_NEEDBITS(e);
00390 zip_copy_leng = t.n + zip_GETBITS(e);
00391 zip_DUMPBITS(e);
00392
00393
00394 zip_NEEDBITS(zip_bd);
00395 t = zip_td.list[zip_GETBITS(zip_bd)];
00396 e = t.e;
00397
00398 while (e > 16) {
00399 if (e == 99)
00400 return -1;
00401 zip_DUMPBITS(t.b);
00402 e -= 16;
00403 zip_NEEDBITS(e);
00404 t = t.t[zip_GETBITS(e)];
00405 e = t.e;
00406 }
00407 zip_DUMPBITS(t.b);
00408 zip_NEEDBITS(e);
00409 zip_copy_dist = zip_wp - t.n - zip_GETBITS(e);
00410 zip_DUMPBITS(e);
00411
00412
00413 while (zip_copy_leng > 0 && n < size) {
00414 zip_copy_leng--;
00415 zip_copy_dist &= zip_WSIZE - 1;
00416 zip_wp &= zip_WSIZE - 1;
00417 buff[off + n++] = zip_slide[zip_wp++] = zip_slide[zip_copy_dist++];
00418 }
00419
00420 if (n == size)
00421 return size;
00422 }
00423
00424 zip_method = -1;
00425 return n;
00426 }
00427
00428 var zip_inflate_stored = function(buff, off, size) {
00429
00430 var n;
00431
00432
00433 n = zip_bit_len & 7;
00434 zip_DUMPBITS(n);
00435
00436
00437 zip_NEEDBITS(16);
00438 n = zip_GETBITS(16);
00439 zip_DUMPBITS(16);
00440 zip_NEEDBITS(16);
00441 if (n != ((~zip_bit_buf) & 0xffff))
00442 return -1;
00443 zip_DUMPBITS(16);
00444
00445
00446 zip_copy_leng = n;
00447
00448 n = 0;
00449 while (zip_copy_leng > 0 && n < size) {
00450 zip_copy_leng--;
00451 zip_wp &= zip_WSIZE - 1;
00452 zip_NEEDBITS(8);
00453 buff[off + n++] = zip_slide[zip_wp++] = zip_GETBITS(8);
00454 zip_DUMPBITS(8);
00455 }
00456
00457 if (zip_copy_leng == 0)
00458 zip_method = -1;
00459 return n;
00460 }
00461
00462 var zip_inflate_fixed = function(buff, off, size) {
00463
00464
00465
00466
00467
00468 if (zip_fixed_tl == null) {
00469 var i;
00470 var l = new Array(288);
00471 var h;
00472
00473
00474 for (i = 0; i < 144; ++i)
00475 l[i] = 8;
00476 for (; i < 256; ++i)
00477 l[i] = 9;
00478 for (; i < 280; ++i)
00479 l[i] = 7;
00480 for (; i < 288; ++i)
00481 l[i] = 8;
00482 zip_fixed_bl = 7;
00483
00484 h = new zip_HuftBuild(l, 288, 257, zip_cplens, zip_cplext,
00485 zip_fixed_bl);
00486 if (h.status != 0) {
00487 alert("HufBuild error: "+h.status);
00488 return -1;
00489 }
00490 zip_fixed_tl = h.root;
00491 zip_fixed_bl = h.m;
00492
00493
00494 for (i = 0; i < 30; ++i)
00495 l[i] = 5;
00496 zip_fixed_bd = 5;
00497
00498 h = new zip_HuftBuild(l, 30, 0, zip_cpdist, zip_cpdext,
00499 zip_fixed_bd);
00500 if (h.status > 1) {
00501 zip_fixed_tl = null;
00502 alert("HufBuild error: "+h.status);
00503 return -1;
00504 }
00505 zip_fixed_td = h.root;
00506 zip_fixed_bd = h.m;
00507 }
00508
00509 zip_tl = zip_fixed_tl;
00510 zip_td = zip_fixed_td;
00511 zip_bl = zip_fixed_bl;
00512 zip_bd = zip_fixed_bd;
00513 return zip_inflate_codes(buff, off, size);
00514 }
00515
00516 var zip_inflate_dynamic = function(buff, off, size) {
00517
00518 var i;
00519 var j;
00520 var l;
00521 var n;
00522 var t;
00523 var nb;
00524 var nl;
00525 var nd;
00526 var ll = new Array(286+30);
00527 var h;
00528
00529 for (i = 0; i < ll.length; ++i)
00530 ll[i] = 0;
00531
00532
00533 zip_NEEDBITS(5);
00534 nl = 257 + zip_GETBITS(5);
00535 zip_DUMPBITS(5);
00536 zip_NEEDBITS(5);
00537 nd = 1 + zip_GETBITS(5);
00538 zip_DUMPBITS(5);
00539 zip_NEEDBITS(4);
00540 nb = 4 + zip_GETBITS(4);
00541 zip_DUMPBITS(4);
00542 if (nl > 286 || nd > 30)
00543 return -1;
00544
00545
00546 for (j = 0; j < nb; ++j) {
00547 zip_NEEDBITS(3);
00548 ll[zip_border[j]] = zip_GETBITS(3);
00549 zip_DUMPBITS(3);
00550 }
00551 for (; j < 19; ++j)
00552 ll[zip_border[j]] = 0;
00553
00554
00555 zip_bl = 7;
00556 h = new zip_HuftBuild(ll, 19, 19, null, null, zip_bl);
00557 if (h.status != 0)
00558 return -1;
00559
00560 zip_tl = h.root;
00561 zip_bl = h.m;
00562
00563
00564 n = nl + nd;
00565 i = l = 0;
00566 while (i < n) {
00567 zip_NEEDBITS(zip_bl);
00568 t = zip_tl.list[zip_GETBITS(zip_bl)];
00569 j = t.b;
00570 zip_DUMPBITS(j);
00571 j = t.n;
00572 if (j < 16)
00573 ll[i++] = l = j;
00574 else if (j == 16) {
00575 zip_NEEDBITS(2);
00576 j = 3 + zip_GETBITS(2);
00577 zip_DUMPBITS(2);
00578 if (i + j > n)
00579 return -1;
00580 while (j-- > 0)
00581 ll[i++] = l;
00582 } else if (j == 17) {
00583 zip_NEEDBITS(3);
00584 j = 3 + zip_GETBITS(3);
00585 zip_DUMPBITS(3);
00586 if (i + j > n)
00587 return -1;
00588 while (j-- > 0)
00589 ll[i++] = 0;
00590 l = 0;
00591 } else {
00592 zip_NEEDBITS(7);
00593 j = 11 + zip_GETBITS(7);
00594 zip_DUMPBITS(7);
00595 if (i + j > n)
00596 return -1;
00597 while (j-- > 0)
00598 ll[i++] = 0;
00599 l = 0;
00600 }
00601 }
00602
00603
00604 zip_bl = zip_lbits;
00605 h = new zip_HuftBuild(ll, nl, 257, zip_cplens, zip_cplext, zip_bl);
00606 if (zip_bl == 0)
00607 h.status = 1;
00608 if (h.status != 0) {
00609 if (h.status == 1)
00610 ;
00611 return -1;
00612 }
00613 zip_tl = h.root;
00614 zip_bl = h.m;
00615
00616 for (i = 0; i < nd; ++i)
00617 ll[i] = ll[i + nl];
00618 zip_bd = zip_dbits;
00619 h = new zip_HuftBuild(ll, nd, 0, zip_cpdist, zip_cpdext, zip_bd);
00620 zip_td = h.root;
00621 zip_bd = h.m;
00622
00623 if (zip_bd == 0 && nl > 257) {
00624
00625 return -1;
00626 }
00627
00628 if (h.status == 1) {
00629 ;
00630 }
00631 if (h.status != 0)
00632 return -1;
00633
00634
00635 return zip_inflate_codes(buff, off, size);
00636 }
00637
00638 var zip_inflate_start = function() {
00639
00640 var i;
00641
00642 if (zip_slide == null)
00643 zip_slide = new Array(2 * zip_WSIZE);
00644 zip_wp = 0;
00645 zip_bit_buf = 0;
00646 zip_bit_len = 0;
00647 zip_method = -1;
00648 zip_eof = false;
00649 zip_copy_leng = zip_copy_dist = 0;
00650 zip_tl = null;
00651 }
00652
00653 var zip_inflate_internal = function(buff, off, size) {
00654
00655 var n, i;
00656
00657 n = 0;
00658 while (n < size) {
00659 if (zip_eof && zip_method == -1)
00660 return n;
00661
00662 if (zip_copy_leng > 0) {
00663 if (zip_method != zip_STORED_BLOCK) {
00664
00665 while (zip_copy_leng > 0 && n < size) {
00666 zip_copy_leng--;
00667 zip_copy_dist &= zip_WSIZE - 1;
00668 zip_wp &= zip_WSIZE - 1;
00669 buff[off + n++] = zip_slide[zip_wp++] =
00670 zip_slide[zip_copy_dist++];
00671 }
00672 } else {
00673 while (zip_copy_leng > 0 && n < size) {
00674 zip_copy_leng--;
00675 zip_wp &= zip_WSIZE - 1;
00676 zip_NEEDBITS(8);
00677 buff[off + n++] = zip_slide[zip_wp++] = zip_GETBITS(8);
00678 zip_DUMPBITS(8);
00679 }
00680 if (zip_copy_leng == 0)
00681 zip_method = -1;
00682 }
00683 if (n == size)
00684 return n;
00685 }
00686
00687 if (zip_method == -1) {
00688 if (zip_eof)
00689 break;
00690
00691
00692 zip_NEEDBITS(1);
00693 if (zip_GETBITS(1) != 0)
00694 zip_eof = true;
00695 zip_DUMPBITS(1);
00696
00697
00698 zip_NEEDBITS(2);
00699 zip_method = zip_GETBITS(2);
00700 zip_DUMPBITS(2);
00701 zip_tl = null;
00702 zip_copy_leng = 0;
00703 }
00704
00705 switch (zip_method) {
00706 case 0:
00707 i = zip_inflate_stored(buff, off + n, size - n);
00708 break;
00709
00710 case 1:
00711 if (zip_tl != null)
00712 i = zip_inflate_codes(buff, off + n, size - n);
00713 else
00714 i = zip_inflate_fixed(buff, off + n, size - n);
00715 break;
00716
00717 case 2:
00718 if (zip_tl != null)
00719 i = zip_inflate_codes(buff, off + n, size - n);
00720 else
00721 i = zip_inflate_dynamic(buff, off + n, size - n);
00722 break;
00723
00724 default:
00725 i = -1;
00726 break;
00727 }
00728
00729 if (i == -1) {
00730 if (zip_eof)
00731 return 0;
00732 return -1;
00733 }
00734 n += i;
00735 }
00736 return n;
00737 }
00738
00739 var zip_inflate = function(str)
00740 {
00741 var i, j;
00742
00743 zip_inflate_start();
00744 zip_inflate_data = str;
00745 zip_inflate_pos = 0;
00746
00747 zip_NEEDBITS = zip_NEEDBITS_DFLT;
00748
00749 var buff = new Array(1024);
00750 var aout = [];
00751 while ((i = zip_inflate_internal(buff, 0, buff.length)) > 0) {
00752 var cbuf = new Array(i);
00753 for (j = 0; j < i; ++j) {
00754 cbuf[j] = String.fromCharCode(buff[j]);
00755 }
00756 aout[aout.length] = cbuf.join("");
00757 }
00758 zip_inflate_data = null;
00759 return aout.join("");
00760 }
00761
00762 var zip_inflate_arr = function(arr, tgt)
00763 {
00764 var i, j;
00765
00766 zip_inflate_start();
00767 zip_inflate_data = arr;
00768 zip_inflate_pos = 0;
00769 zip_NEEDBITS = zip_NEEDBITS_ARR;
00770
00771 var cnt = 0;
00772 while ((i = zip_inflate_internal(tgt, cnt, Math.min(1024, tgt.byteLength-cnt))) > 0) {
00773 cnt += i;
00774 }
00775 zip_inflate_data = null;
00776
00777 return cnt;
00778 }
00779
00780
00781 if (! window.RawInflate) RawInflate = {};
00782
00783 RawInflate.inflate = zip_inflate;
00784 RawInflate.arr_inflate = zip_inflate_arr;
00785
00786 })();