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
00322 var zip_NEEDBITS = function(n) {
00323 while (zip_bit_len < n) {
00324 zip_bit_buf |= zip_GET_BYTE() << zip_bit_len;
00325 zip_bit_len += 8;
00326 }
00327 }
00328
00329 var zip_GETBITS = function(n) {
00330 return zip_bit_buf & zip_MASK_BITS[n];
00331 }
00332
00333 var zip_DUMPBITS = function(n) {
00334 zip_bit_buf >>= n;
00335 zip_bit_len -= n;
00336 }
00337
00338 var zip_inflate_codes = function(buff, off, size) {
00339
00340
00341 var e;
00342 var t;
00343 var n;
00344
00345 if (size == 0)
00346 return 0;
00347
00348
00349 n = 0;
00350 for (;;) {
00351 zip_NEEDBITS(zip_bl);
00352 t = zip_tl.list[zip_GETBITS(zip_bl)];
00353 e = t.e;
00354 while (e > 16) {
00355 if (e == 99)
00356 return -1;
00357 zip_DUMPBITS(t.b);
00358 e -= 16;
00359 zip_NEEDBITS(e);
00360 t = t.t[zip_GETBITS(e)];
00361 e = t.e;
00362 }
00363 zip_DUMPBITS(t.b);
00364
00365 if (e == 16) {
00366 zip_wp &= zip_WSIZE - 1;
00367 buff[off + n++] = zip_slide[zip_wp++] = t.n;
00368 if (n == size)
00369 return size;
00370 continue;
00371 }
00372
00373
00374 if (e == 15)
00375 break;
00376
00377
00378
00379
00380 zip_NEEDBITS(e);
00381 zip_copy_leng = t.n + zip_GETBITS(e);
00382 zip_DUMPBITS(e);
00383
00384
00385 zip_NEEDBITS(zip_bd);
00386 t = zip_td.list[zip_GETBITS(zip_bd)];
00387 e = t.e;
00388
00389 while (e > 16) {
00390 if (e == 99)
00391 return -1;
00392 zip_DUMPBITS(t.b);
00393 e -= 16;
00394 zip_NEEDBITS(e);
00395 t = t.t[zip_GETBITS(e)];
00396 e = t.e;
00397 }
00398 zip_DUMPBITS(t.b);
00399 zip_NEEDBITS(e);
00400 zip_copy_dist = zip_wp - t.n - zip_GETBITS(e);
00401 zip_DUMPBITS(e);
00402
00403
00404 while (zip_copy_leng > 0 && n < size) {
00405 zip_copy_leng--;
00406 zip_copy_dist &= zip_WSIZE - 1;
00407 zip_wp &= zip_WSIZE - 1;
00408 buff[off + n++] = zip_slide[zip_wp++] = zip_slide[zip_copy_dist++];
00409 }
00410
00411 if (n == size)
00412 return size;
00413 }
00414
00415 zip_method = -1;
00416 return n;
00417 }
00418
00419 var zip_inflate_stored = function(buff, off, size) {
00420
00421 var n;
00422
00423
00424 n = zip_bit_len & 7;
00425 zip_DUMPBITS(n);
00426
00427
00428 zip_NEEDBITS(16);
00429 n = zip_GETBITS(16);
00430 zip_DUMPBITS(16);
00431 zip_NEEDBITS(16);
00432 if (n != ((~zip_bit_buf) & 0xffff))
00433 return -1;
00434 zip_DUMPBITS(16);
00435
00436
00437 zip_copy_leng = n;
00438
00439 n = 0;
00440 while (zip_copy_leng > 0 && n < size) {
00441 zip_copy_leng--;
00442 zip_wp &= zip_WSIZE - 1;
00443 zip_NEEDBITS(8);
00444 buff[off + n++] = zip_slide[zip_wp++] = zip_GETBITS(8);
00445 zip_DUMPBITS(8);
00446 }
00447
00448 if (zip_copy_leng == 0)
00449 zip_method = -1;
00450 return n;
00451 }
00452
00453 var zip_inflate_fixed = function(buff, off, size) {
00454
00455
00456
00457
00458
00459 if (zip_fixed_tl == null) {
00460 var i;
00461 var l = new Array(288);
00462 var h;
00463
00464
00465 for (i = 0; i < 144; i++)
00466 l[i] = 8;
00467 for (; i < 256; i++)
00468 l[i] = 9;
00469 for (; i < 280; i++)
00470 l[i] = 7;
00471 for (; i < 288; i++)
00472 l[i] = 8;
00473 zip_fixed_bl = 7;
00474
00475 h = new zip_HuftBuild(l, 288, 257, zip_cplens, zip_cplext,
00476 zip_fixed_bl);
00477 if (h.status != 0) {
00478 alert("HufBuild error: "+h.status);
00479 return -1;
00480 }
00481 zip_fixed_tl = h.root;
00482 zip_fixed_bl = h.m;
00483
00484
00485 for (i = 0; i < 30; i++)
00486 l[i] = 5;
00487 zip_fixed_bd = 5;
00488
00489 h = new zip_HuftBuild(l, 30, 0, zip_cpdist, zip_cpdext,
00490 zip_fixed_bd);
00491 if (h.status > 1) {
00492 zip_fixed_tl = null;
00493 alert("HufBuild error: "+h.status);
00494 return -1;
00495 }
00496 zip_fixed_td = h.root;
00497 zip_fixed_bd = h.m;
00498 }
00499
00500 zip_tl = zip_fixed_tl;
00501 zip_td = zip_fixed_td;
00502 zip_bl = zip_fixed_bl;
00503 zip_bd = zip_fixed_bd;
00504 return zip_inflate_codes(buff, off, size);
00505 }
00506
00507 var zip_inflate_dynamic = function(buff, off, size) {
00508
00509 var i;
00510 var j;
00511 var l;
00512 var n;
00513 var t;
00514 var nb;
00515 var nl;
00516 var nd;
00517 var ll = new Array(286+30);
00518 var h;
00519
00520 for (i = 0; i < ll.length; i++)
00521 ll[i] = 0;
00522
00523
00524 zip_NEEDBITS(5);
00525 nl = 257 + zip_GETBITS(5);
00526 zip_DUMPBITS(5);
00527 zip_NEEDBITS(5);
00528 nd = 1 + zip_GETBITS(5);
00529 zip_DUMPBITS(5);
00530 zip_NEEDBITS(4);
00531 nb = 4 + zip_GETBITS(4);
00532 zip_DUMPBITS(4);
00533 if (nl > 286 || nd > 30)
00534 return -1;
00535
00536
00537 for (j = 0; j < nb; j++) {
00538 zip_NEEDBITS(3);
00539 ll[zip_border[j]] = zip_GETBITS(3);
00540 zip_DUMPBITS(3);
00541 }
00542 for (; j < 19; j++)
00543 ll[zip_border[j]] = 0;
00544
00545
00546 zip_bl = 7;
00547 h = new zip_HuftBuild(ll, 19, 19, null, null, zip_bl);
00548 if (h.status != 0)
00549 return -1;
00550
00551 zip_tl = h.root;
00552 zip_bl = h.m;
00553
00554
00555 n = nl + nd;
00556 i = l = 0;
00557 while (i < n) {
00558 zip_NEEDBITS(zip_bl);
00559 t = zip_tl.list[zip_GETBITS(zip_bl)];
00560 j = t.b;
00561 zip_DUMPBITS(j);
00562 j = t.n;
00563 if (j < 16)
00564 ll[i++] = l = j;
00565 else if (j == 16) {
00566 zip_NEEDBITS(2);
00567 j = 3 + zip_GETBITS(2);
00568 zip_DUMPBITS(2);
00569 if (i + j > n)
00570 return -1;
00571 while (j-- > 0)
00572 ll[i++] = l;
00573 } else if (j == 17) {
00574 zip_NEEDBITS(3);
00575 j = 3 + zip_GETBITS(3);
00576 zip_DUMPBITS(3);
00577 if (i + j > n)
00578 return -1;
00579 while (j-- > 0)
00580 ll[i++] = 0;
00581 l = 0;
00582 } else {
00583 zip_NEEDBITS(7);
00584 j = 11 + zip_GETBITS(7);
00585 zip_DUMPBITS(7);
00586 if (i + j > n)
00587 return -1;
00588 while (j-- > 0)
00589 ll[i++] = 0;
00590 l = 0;
00591 }
00592 }
00593
00594
00595 zip_bl = zip_lbits;
00596 h = new zip_HuftBuild(ll, nl, 257, zip_cplens, zip_cplext, zip_bl);
00597 if (zip_bl == 0)
00598 h.status = 1;
00599 if (h.status != 0) {
00600 if (h.status == 1)
00601 ;
00602 return -1;
00603 }
00604 zip_tl = h.root;
00605 zip_bl = h.m;
00606
00607 for (i = 0; i < nd; i++)
00608 ll[i] = ll[i + nl];
00609 zip_bd = zip_dbits;
00610 h = new zip_HuftBuild(ll, nd, 0, zip_cpdist, zip_cpdext, zip_bd);
00611 zip_td = h.root;
00612 zip_bd = h.m;
00613
00614 if (zip_bd == 0 && nl > 257) {
00615
00616 return -1;
00617 }
00618
00619 if (h.status == 1) {
00620 ;
00621 }
00622 if (h.status != 0)
00623 return -1;
00624
00625
00626 return zip_inflate_codes(buff, off, size);
00627 }
00628
00629 var zip_inflate_start = function() {
00630
00631 var i;
00632
00633 if (zip_slide == null)
00634 zip_slide = new Array(2 * zip_WSIZE);
00635 zip_wp = 0;
00636 zip_bit_buf = 0;
00637 zip_bit_len = 0;
00638 zip_method = -1;
00639 zip_eof = false;
00640 zip_copy_leng = zip_copy_dist = 0;
00641 zip_tl = null;
00642 }
00643
00644 var zip_inflate_internal = function(buff, off, size) {
00645
00646 var n, i;
00647
00648 n = 0;
00649 while (n < size) {
00650 if (zip_eof && zip_method == -1)
00651 return n;
00652
00653 if (zip_copy_leng > 0) {
00654 if (zip_method != zip_STORED_BLOCK) {
00655
00656 while (zip_copy_leng > 0 && n < size) {
00657 zip_copy_leng--;
00658 zip_copy_dist &= zip_WSIZE - 1;
00659 zip_wp &= zip_WSIZE - 1;
00660 buff[off + n++] = zip_slide[zip_wp++] =
00661 zip_slide[zip_copy_dist++];
00662 }
00663 } else {
00664 while (zip_copy_leng > 0 && n < size) {
00665 zip_copy_leng--;
00666 zip_wp &= zip_WSIZE - 1;
00667 zip_NEEDBITS(8);
00668 buff[off + n++] = zip_slide[zip_wp++] = zip_GETBITS(8);
00669 zip_DUMPBITS(8);
00670 }
00671 if (zip_copy_leng == 0)
00672 zip_method = -1;
00673 }
00674 if (n == size)
00675 return n;
00676 }
00677
00678 if (zip_method == -1) {
00679 if (zip_eof)
00680 break;
00681
00682
00683 zip_NEEDBITS(1);
00684 if (zip_GETBITS(1) != 0)
00685 zip_eof = true;
00686 zip_DUMPBITS(1);
00687
00688
00689 zip_NEEDBITS(2);
00690 zip_method = zip_GETBITS(2);
00691 zip_DUMPBITS(2);
00692 zip_tl = null;
00693 zip_copy_leng = 0;
00694 }
00695
00696 switch (zip_method) {
00697 case 0:
00698 i = zip_inflate_stored(buff, off + n, size - n);
00699 break;
00700
00701 case 1:
00702 if (zip_tl != null)
00703 i = zip_inflate_codes(buff, off + n, size - n);
00704 else
00705 i = zip_inflate_fixed(buff, off + n, size - n);
00706 break;
00707
00708 case 2:
00709 if (zip_tl != null)
00710 i = zip_inflate_codes(buff, off + n, size - n);
00711 else
00712 i = zip_inflate_dynamic(buff, off + n, size - n);
00713 break;
00714
00715 default:
00716 i = -1;
00717 break;
00718 }
00719
00720 if (i == -1) {
00721 if (zip_eof)
00722 return 0;
00723 return -1;
00724 }
00725 n += i;
00726 }
00727 return n;
00728 }
00729
00730 var zip_inflate = function(str)
00731 {
00732 var i, j;
00733
00734 zip_inflate_start();
00735 zip_inflate_data = str;
00736 zip_inflate_pos = 0;
00737
00738 var buff = new Array(1024);
00739 var aout = [];
00740 while ((i = zip_inflate_internal(buff, 0, buff.length)) > 0) {
00741 var cbuf = new Array(i);
00742 for (j = 0; j < i; j++) {
00743 cbuf[j] = String.fromCharCode(buff[j]);
00744 }
00745 aout[aout.length] = cbuf.join("");
00746 }
00747 zip_inflate_data = null;
00748 return aout.join("");
00749 }
00750
00751 if (! window.RawInflate) RawInflate = {};
00752
00753 RawInflate.inflate = zip_inflate;
00754
00755 })();