Lines Matching refs:s
1962 var s = this.style;
1964 if (s && (s.font || s.numFmt || s.alignment || s.border || s.fill || s.protection)) {
2658 value: function setTLBR(t, l, b, r, s) {
2670 this.setTLBR(tl.row, tl.col, br.row, br.col, s);
2678 sheetName: s
7911 …s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i…
8034 _iterator2.s();
8704 var s = value !== undefined ? model[name] = value : dflt;
8706 if (s !== undefined) {
8707 model[name] = s;
13303 if (node.attributes.s) {
13304 this.model.styleId = parseInt(node.attributes.s, 10);
17834 if (node.attributes.s) {
17835 model.styleId = parseInt(node.attributes.s, 10);
31159 for (var s = 1; s < N; s <<= 1) {
31160 var l = s << 1;
31168 for (var j = 0; j < s; j++) {
31171 var ro = rtws[p + j + s];
31172 var io = itws[p + j + s];
31178 rtws[p + j + s] = re - ro;
31179 itws[p + j + s] = ie - io;
31380 var s = (bits - r) / 26;
31400 if (s !== 0) {
31402 this.words[i + s] = this.words[i];
31405 for (i = 0; i < s; i++) {
31409 this.length += s;
31435 var s = Math.min((bits - r) / 26, this.length);
31438 h -= s;
31442 for (var i = 0; i < s; i++) {
31446 maskedWords.length = s;
31449 if (s === 0) {// No-op, we should not move anything at all
31450 } else if (this.length > s) {
31451 this.length -= s;
31454 this.words[i] = this.words[i + s];
31510 var s = (bit - r) / 26;
31513 if (this.length <= s) return false; // Check bit and return
31515 var w = this.words[s];
31523 var s = (bits - r) / 26;
31526 if (this.length <= s) {
31531 s++;
31534 this.length = Math.min(s, this.length);
32135 var s = (bit - r) / 26;
32138 if (this.length <= s) {
32139 this._expand(s + 1);
32141 this.words[s] |= q;
32148 for (var i = s; carry !== 0 && i < this.length; i++) {
32708 var s = 0;
32711 s++;
32731 var m = s;
34845 for (var s = 1; s < N; s <<= 1) {
34846 var l = s << 1;
34854 for (var j = 0; j < s; j++) {
34857 var ro = rtws[p + j + s];
34858 var io = itws[p + j + s];
34864 rtws[p + j + s] = re - ro;
34865 itws[p + j + s] = ie - io;
35068 var s = (bits - r) / 26;
35088 if (s !== 0) {
35090 this.words[i + s] = this.words[i];
35093 for (i = 0; i < s; i++) {
35097 this.length += s;
35123 var s = Math.min((bits - r) / 26, this.length);
35126 h -= s;
35130 for (var i = 0; i < s; i++) {
35134 maskedWords.length = s;
35137 if (s === 0) {// No-op, we should not move anything at all
35138 } else if (this.length > s) {
35139 this.length -= s;
35142 this.words[i] = this.words[i + s];
35198 var s = (bit - r) / 26;
35201 if (this.length <= s) return false; // Check bit and return
35203 var w = this.words[s];
35211 var s = (bits - r) / 26;
35214 if (this.length <= s) {
35219 s++;
35222 this.length = Math.min(s, this.length);
35835 var s = (bit - r) / 26;
35838 if (this.length <= s) {
35839 this._expand(s + 1);
35841 this.words[s] |= q;
35848 for (var i = s; carry !== 0 && i < this.length; i++) {
36411 var s = 0;
36414 s++;
36434 var m = s;
38458 var s = false;
38461 while (s === false) {
38464 s = k.invm(q).imul(H.add(x.mul(r))).mod(q);
38466 if (s.cmpn(0) === 0) {
38467 s = false;
38472 return toDER(r, s);
38475 function toDER(r, s) {
38477 s = s.toArray(); // Pad values
38480 if (s[0] & 0x80) s = [0].concat(s);
38481 var total = r.length + s.length + 4;
38483 res = res.concat(r, [0x02, s.length], s);
38634 var s = unpacked.s;
38636 checkValue(s, q);
38639 var w = s.invm(q);
44018 s = "week",
44030 s: d,
44042 s = n - i < 0,
44043 a = e.add(r + (s ? -1 : 1), u);
44044 return +(-(r + (n - i) / (s ? i - a : a - i)) || 0);
44053 w: s,
44058 s: e,
44123 s = (r[7] || "0").substring(0, 3);
44124 …3] || 1, r[4] || 0, r[5] || 0, r[6] || 0, s)) : new Date(r[1], i, r[3] || 1, r[4] || 0, r[5] || 0,…
44173 case s:
44196 }, $.$set = function (s, a) {
44198 c = g.p(s),
44227 if (c === s) return d(7);
44240 s = this.$H,
44245 h = function h(t, r, i, s) {
44246 return t && (t[r] || t(e, n)) || i[r].substr(0, s);
44249 return g.s(s % 12 || 12, t, "0");
44259 MM: g.s(a + 1, 2, "0"),
44263 DD: g.s(this.$D, 2, "0"),
44268 H: String(s),
44269 HH: g.s(s, 2, "0"),
44272 a: $(s, u, !0),
44273 A: $(s, u, !1),
44275 mm: g.s(u, 2, "0"),
44276 s: String(this.$s),
44277 ss: g.s(this.$s, 2, "0"),
44278 SSS: g.s(this.$ms, 3, "0"),
44294 …return M = (c = {}, c[o] = M / 12, c[u] = M, c[a] = M / 3, c[s] = (y - l) / 6048e5, c[i] = (y - l)…
44340 e = /(\[[^[]*\])|([-:/.()\s]+)|(A|a|YYYY|YY?|MM?M?M?|Do|DD?|hh?|HH?|mm?|ss?|S{1,3}|z|ZZ?)/g,
44350 s = [/[+-]\d\d:?\d\d/, function (t) {
44356 return n && (n.indexOf ? n : n.s.concat(n.f));
44374 s: [r, i("seconds")],
44411 Z: s,
44412 ZZ: s
44420 s = h[i],
44421 a = s && s[0],
44422 f = s && s[1];
44431 var s = n[o];
44432 if ("string" == typeof s) i += s.length;else {
44433 var a = s.regex,
44434 h = s.parser,
44452 s = o.month,
44460 v = a || (i || s ? 1 : m.getDate()),
44464 i && !s || (y = s > 0 ? s - 1 : m.getMonth());
44482 s = e.args;
44484 var a = s[1];
44487 var h = !0 === s[2],
44488 u = !0 === s[3],
44490 c = s[2];
44491 …u && (c = s[2]), h || (t = c ? r.Ls[c] : this.$locale()), this.$d = f(n, a, o), this.init(), c && …
44493 s[1] = a[m - 1];
44494 var v = r.apply(this, s);
44518 var s = new Date().getTimezoneOffset(),
44559 …return i ? (u.$offset = n, u.$u = 0 === t, u) : (0 !== t ? (u = this.local().add(n + s, "minute"))…
44567 var t = this.$utils().u(this.$offset) ? 0 : this.$offset + s;
44584 n.diff = function (t, i, s) {
44587 return c.call(n, u, i, s);
44901 var s = utils.substitute(keyL, keyR);
44902 var f = utils.permute(s);
44923 var s = utils.substitute(keyL, keyR);
44924 var f = utils.permute(s);
46655 var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv);
46656 var l1 = ntinv.redAdd(s).fromRed();
46657 var l2 = ntinv.redSub(s).fromRed();
47181 var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
47182 s = s.redIAdd(s); // M = 3 * XX + a; a = 0
47186 var t = m.redSqr().redISub(s).redISub(s); // 8 * YYYY
47194 ny = m.redMul(s.redISub(t)).redISub(yyyy8); // Z3 = 2*Y1
47246 var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
47247 s = s.redIAdd(s); // M = 3 * XX + a
47251 var t = m.redSqr().redISub(s).redISub(s); // X3 = T
47258 ny = m.redMul(s.redISub(t)).redISub(yyyy8); // Z3 = 2 * Y1
47676 var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg));
47677 s = s.umod(this.n);
47678 if (s.cmpn(0) === 0) continue;
47681 if (options.canonical && s.cmp(this.nh) > 0) {
47682 s = this.n.sub(s);
47688 s: s,
47700 var s = signature.s;
47702 if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0) return false; // Validate signature
47704 var sinv = s.invm(this.n);
47730 var s = signature.s; // A set LSB signifies that the y-coordinate is odd
47739 var s2 = s.mul(rInv).umod(n); // 1.6.1 Compute Q = r^-1 (sR - eG)
47891 assert(options.r && options.s, 'Signature without r or s');
47893 this.s = new BN(options.s, 16);
47993 var s = data.slice(p.place, slen + p.place);
48004 if (s[0] === 0) {
48005 if (s[1] & 0x80) {
48006 s = s.slice(1);
48014 this.s = new BN(s);
48037 var s = this.s.toArray(); // Pad values
48041 if (s[0] & 0x80) s = [0].concat(s);
48043 s = rmPadding(s);
48045 while (!s[0] && !(s[1] & 0x80)) {
48046 s = s.slice(1);
48053 constructLength(arr, s.length);
48054 var backHalf = arr.concat(s);
49541 var T = sum32(rotl32(sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)), s[j]), E);
49581 var s = [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, …
49641 var s = ~~(i / 20);
49642 var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]);
50043 function ft_1(s, x, y, z) {
50044 if (s === 0) return ch32(x, y, z);
50045 if (s === 1 || s === 3) return p32(x, y, z);
50046 if (s === 2) return maj32(x, y, z);
50505 var s = buffer[offset + i];
50507 e = s & (1 << -nBits) - 1;
50508 s >>= -nBits;
50522 return m ? NaN : (s ? -1 : 1) * Infinity;
50528 return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
50539 var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
50583 buffer[offset + i - d] |= s * 128;
61554 function fnF(a, b, c, d, m, k, s) {
61555 return rotl(a + (b & c | ~b & d) + m + k | 0, s) + b | 0;
61558 function fnG(a, b, c, d, m, k, s) {
61559 return rotl(a + (b & d | c & ~d) + m + k | 0, s) + b | 0;
61562 function fnH(a, b, c, d, m, k, s) {
61563 return rotl(a + (b ^ c ^ d) + m + k | 0, s) + b | 0;
61566 function fnI(a, b, c, d, m, k, s) {
61567 return rotl(a + (c ^ (b | ~d)) + m + k | 0, s) + b | 0;
61615 for (var s = 0; !n1.testn(s); s++) {}
61617 var d = n.shrn(s);
61628 for (var i = 1; i < s; i++) {
61634 if (i === s) return false;
61648 for (var s = 0; !n1.testn(s); s++) {}
61650 var d = n.shrn(s);
61661 for (var i = 1; i < s; i++) {
61667 if (i === s) {
63260 var s = strm.state; //_tr_flush_bits(s);
63262 var len = s.pending;
63272 utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out);
63274 s.pending_out += len;
63277 s.pending -= len;
63279 if (s.pending === 0) {
63280 s.pending_out = 0;
63284 function flush_block_only(s, last) {
63285 …trees._tr_flush_block(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last…
63287 s.block_start = s.strstart;
63288 flush_pending(s.strm);
63291 function put_byte(s, b) {
63292 s.pending_buf[s.pending++] = b;
63301 function putShortMSB(s, b) {
63304 s.pending_buf[s.pending++] = b >>> 8 & 0xff;
63305 s.pending_buf[s.pending++] = b & 0xff;
63352 function longest_match(s, cur_match) {
63353 var chain_length = s.max_chain_length;
63356 var scan = s.strstart;
63365 var best_len = s.prev_length;
63368 var nice_match = s.nice_match;
63371 var limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0
63374 var _win = s.window; // shortcut
63376 var wmask = s.w_mask;
63377 var prev = s.prev;
63382 var strend = s.strstart + MAX_MATCH;
63392 if (s.prev_length >= s.good_match) {
63400 if (nice_match > s.lookahead) {
63401 nice_match = s.lookahead;
63444 s.match_start = cur_match;
63456 if (best_len <= s.lookahead) {
63460 return s.lookahead;
63474 function fill_window(s) {
63475 var _w_size = s.w_size;
63479 more = s.window_size - s.lookahead - s.strstart; // JS ints have 32 bit, block below not needed
63498 if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {
63499 utils.arraySet(s.window, s.window, _w_size, _w_size, 0);
63500 s.match_start -= _w_size;
63501 s.strstart -= _w_size;
63504 s.block_start -= _w_size;
63512 n = s.hash_size;
63516 m = s.head[--p];
63517 s.head[p] = m >= _w_size ? m - _w_size : 0;
63524 m = s.prev[--p];
63525 s.prev[p] = m >= _w_size ? m - _w_size : 0;
63534 if (s.strm.avail_in === 0) {
63551 n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);
63552 s.lookahead += n;
63555 if (s.lookahead + s.insert >= MIN_MATCH) {
63556 str = s.strstart - s.insert;
63557 s.ins_h = s.window[str];
63560 s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + 1]) & s.hash_mask; //#if MIN_MATCH != 3
63564 while (s.insert) {
63566 s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;
63567 s.prev[str & s.w_mask] = s.head[s.ins_h];
63568 s.head[s.ins_h] = str;
63570 s.insert--;
63572 if (s.lookahead + s.insert < MIN_MATCH) {
63581 } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);
63631 function deflate_stored(s, flush) {
63637 if (max_block_size > s.pending_buf_size - 5) {
63638 max_block_size = s.pending_buf_size - 5;
63645 if (s.lookahead <= 1) {
63652 fill_window(s);
63654 if (s.lookahead === 0 && flush === Z_NO_FLUSH) {
63658 if (s.lookahead === 0) {
63667 s.strstart += s.lookahead;
63668 s.lookahead = 0;
63671 var max_start = s.block_start + max_block_size;
63673 if (s.strstart === 0 || s.strstart >= max_start) {
63675 s.lookahead = s.strstart - max_start;
63676 s.strstart = max_start;
63679 flush_block_only(s, false);
63681 if (s.strm.avail_out === 0) {
63692 if (s.strstart - s.block_start >= s.w_size - MIN_LOOKAHEAD) {
63694 flush_block_only(s, false);
63696 if (s.strm.avail_out === 0) {
63704 s.insert = 0;
63708 flush_block_only(s, true);
63710 if (s.strm.avail_out === 0) {
63719 if (s.strstart > s.block_start) {
63721 flush_block_only(s, false);
63723 if (s.strm.avail_out === 0) {
63741 function deflate_fast(s, flush) {
63754 if (s.lookahead < MIN_LOOKAHEAD) {
63755 fill_window(s);
63757 if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
63761 if (s.lookahead === 0) {
63775 if (s.lookahead >= MIN_MATCH) {
63777 s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
63778 hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
63779 s.head[s.ins_h] = s.strstart;
63789 && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) {
63794 s.match_length = longest_match(s, hash_head);
63798 if (s.match_length >= MIN_MATCH) {
63803 bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH);
63804 s.lookahead -= s.match_length;
63809 if (s.match_length <= s.max_lazy_match
63811 && s.lookahead >= MIN_MATCH) {
63812 s.match_length--;
63816 s.strstart++;
63819 s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
63820 hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
63821 s.head[s.ins_h] = s.strstart;
63827 } while (--s.match_length !== 0);
63829 s.strstart++;
63831 s.strstart += s.match_length;
63832 s.match_length = 0;
63833 s.ins_h = s.window[s.strstart];
63836 … s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + 1]) & s.hash_mask; //#if MIN_MATCH != 3
63849 bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
63850 s.lookahead--;
63851 s.strstart++;
63856 flush_block_only(s, false);
63858 if (s.strm.avail_out === 0) {
63866 s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;
63870 flush_block_only(s, true);
63872 if (s.strm.avail_out === 0) {
63881 if (s.last_lit) {
63883 flush_block_only(s, false);
63885 if (s.strm.avail_out === 0) {
63901 function deflate_slow(s, flush) {
63917 if (s.lookahead < MIN_LOOKAHEAD) {
63918 fill_window(s);
63920 if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
63924 if (s.lookahead === 0) {
63939 if (s.lookahead >= MIN_MATCH) {
63941 s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
63942 hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
63943 s.head[s.ins_h] = s.strstart;
63950 s.prev_length = s.match_length;
63951 s.prev_match = s.match_start;
63952 s.match_length = MIN_MATCH - 1;
63956 && s.prev_length < s.max_lazy_match && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD
63963 s.match_length = longest_match(s, hash_head);
63966 …if (s.match_length <= 5 && (s.strategy === Z_FILTERED || s.match_length === MIN_MATCH && s.strstar…
63972 s.match_length = MIN_MATCH - 1;
63980 if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) {
63981 max_insert = s.strstart + s.lookahead - MIN_MATCH;
63988 bflush = trees._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH);
63995 s.lookahead -= s.prev_length - 1;
63996 s.prev_length -= 2;
63999 if (++s.strstart <= max_insert) {
64001 s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
64002 hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
64003 s.head[s.ins_h] = s.strstart;
64006 } while (--s.prev_length !== 0);
64008 s.match_available = 0;
64009 s.match_length = MIN_MATCH - 1;
64010 s.strstart++;
64014 flush_block_only(s, false);
64016 if (s.strm.avail_out === 0) {
64022 } else if (s.match_available) {
64030 bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);
64034 flush_block_only(s, false);
64038 s.strstart++;
64039 s.lookahead--;
64041 if (s.strm.avail_out === 0) {
64048 s.match_available = 1;
64049 s.strstart++;
64050 s.lookahead--;
64055 if (s.match_available) {
64059 bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);
64060 s.match_available = 0;
64063 s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;
64067 flush_block_only(s, true);
64069 if (s.strm.avail_out === 0) {
64078 if (s.last_lit) {
64080 flush_block_only(s, false);
64082 if (s.strm.avail_out === 0) {
64098 function deflate_rle(s, flush) {
64108 var _win = s.window;
64115 if (s.lookahead <= MAX_MATCH) {
64116 fill_window(s);
64118 if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) {
64122 if (s.lookahead === 0) {
64131 s.match_length = 0;
64133 if (s.lookahead >= MIN_MATCH && s.strstart > 0) {
64134 scan = s.strstart - 1;
64138 strend = s.strstart + MAX_MATCH;
64144 s.match_length = MAX_MATCH - (strend - scan);
64146 if (s.match_length > s.lookahead) {
64147 s.match_length = s.lookahead;
64155 if (s.match_length >= MIN_MATCH) {
64159 bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH);
64160 s.lookahead -= s.match_length;
64161 s.strstart += s.match_length;
64162 s.match_length = 0;
64168 bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
64169 s.lookahead--;
64170 s.strstart++;
64175 flush_block_only(s, false);
64177 if (s.strm.avail_out === 0) {
64185 s.insert = 0;
64189 flush_block_only(s, true);
64191 if (s.strm.avail_out === 0) {
64200 if (s.last_lit) {
64202 flush_block_only(s, false);
64204 if (s.strm.avail_out === 0) {
64219 function deflate_huff(s, flush) {
64225 if (s.lookahead === 0) {
64226 fill_window(s);
64228 if (s.lookahead === 0) {
64240 s.match_length = 0; //Tracevv((stderr,"%c", s->window[s->strstart]));
64244 bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
64245 s.lookahead--;
64246 s.strstart++;
64250 flush_block_only(s, false);
64252 if (s.strm.avail_out === 0) {
64260 s.insert = 0;
64264 flush_block_only(s, true);
64266 if (s.strm.avail_out === 0) {
64275 if (s.last_lit) {
64277 flush_block_only(s, false);
64279 if (s.strm.avail_out === 0) {
64331 function lm_init(s) {
64332 s.window_size = 2 * s.w_size;
64335 zero(s.head); // Fill with NIL (= 0);
64340 s.max_lazy_match = configuration_table[s.level].max_lazy;
64341 s.good_match = configuration_table[s.level].good_length;
64342 s.nice_match = configuration_table[s.level].nice_length;
64343 s.max_chain_length = configuration_table[s.level].max_chain;
64344 s.strstart = 0;
64345 s.block_start = 0;
64346 s.lookahead = 0;
64347 s.insert = 0;
64348 s.match_length = s.prev_length = MIN_MATCH - 1;
64349 s.match_available = 0;
64350 s.ins_h = 0;
64610 var s;
64618 s = strm.state;
64619 s.pending = 0;
64620 s.pending_out = 0;
64622 if (s.wrap < 0) {
64623 s.wrap = -s.wrap;
64627 s.status = s.wrap ? INIT_STATE : BUSY_STATE;
64628 strm.adler = s.wrap === 2 ? 0 // crc32(0, Z_NULL, 0)
64631 s.last_flush = Z_NO_FLUSH;
64633 trees._tr_init(s);
64694 var s = new DeflateState();
64695 strm.state = s;
64696 s.strm = strm;
64697 s.wrap = wrap;
64698 s.gzhead = null;
64699 s.w_bits = windowBits;
64700 s.w_size = 1 << s.w_bits;
64701 s.w_mask = s.w_size - 1;
64702 s.hash_bits = memLevel + 7;
64703 s.hash_size = 1 << s.hash_bits;
64704 s.hash_mask = s.hash_size - 1;
64705 s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);
64706 s.window = new utils.Buf8(s.w_size * 2);
64707 s.head = new utils.Buf16(s.hash_size);
64708 s.prev = new utils.Buf16(s.w_size); // Don't need mem init magic for JS.
64711 s.lit_bufsize = 1 << memLevel + 6;
64714 …s.pending_buf_size = s.lit_bufsize * 4; //overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(u…
64717 …s.pending_buf = new utils.Buf8(s.pending_buf_size); // It is offset from `s.pending_buf` (size is …
64720 s.d_buf = 1 * s.lit_bufsize; //s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
64722 s.l_buf = (1 + 2) * s.lit_bufsize;
64723 s.level = level;
64724 s.strategy = strategy;
64725 s.method = method;
64734 var old_flush, s;
64741 s = strm.state;
64743 …if (!strm.output || !strm.input && strm.avail_in !== 0 || s.status === FINISH_STATE && flush !== Z…
64747 s.strm = strm;
64750 old_flush = s.last_flush;
64751 s.last_flush = flush;
64754 if (s.status === INIT_STATE) {
64755 if (s.wrap === 2) {
64759 put_byte(s, 31);
64760 put_byte(s, 139);
64761 put_byte(s, 8);
64763 if (!s.gzhead) {
64765 put_byte(s, 0);
64766 put_byte(s, 0);
64767 put_byte(s, 0);
64768 put_byte(s, 0);
64769 put_byte(s, 0);
64770 put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);
64771 put_byte(s, OS_CODE);
64772 s.status = BUSY_STATE;
64774 …put_byte(s, (s.gzhead.text ? 1 : 0) + (s.gzhead.hcrc ? 2 : 0) + (!s.gzhead.extra ? 0 : 4) + (!s.gz…
64775 put_byte(s, s.gzhead.time & 0xff);
64776 put_byte(s, s.gzhead.time >> 8 & 0xff);
64777 put_byte(s, s.gzhead.time >> 16 & 0xff);
64778 put_byte(s, s.gzhead.time >> 24 & 0xff);
64779 put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);
64780 put_byte(s, s.gzhead.os & 0xff);
64782 if (s.gzhead.extra && s.gzhead.extra.length) {
64783 put_byte(s, s.gzhead.extra.length & 0xff);
64784 put_byte(s, s.gzhead.extra.length >> 8 & 0xff);
64787 if (s.gzhead.hcrc) {
64788 strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0);
64791 s.gzindex = 0;
64792 s.status = EXTRA_STATE;
64796 var header = Z_DEFLATED + (s.w_bits - 8 << 4) << 8;
64799 if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {
64801 } else if (s.level < 6) {
64803 } else if (s.level === 6) {
64811 if (s.strstart !== 0) {
64816 s.status = BUSY_STATE;
64817 putShortMSB(s, header);
64820 if (s.strstart !== 0) {
64821 putShortMSB(s, strm.adler >>> 16);
64822 putShortMSB(s, strm.adler & 0xffff);
64830 if (s.status === EXTRA_STATE) {
64831 if (s.gzhead.extra
64834 beg = s.pending;
64837 while (s.gzindex < (s.gzhead.extra.length & 0xffff)) {
64838 if (s.pending === s.pending_buf_size) {
64839 if (s.gzhead.hcrc && s.pending > beg) {
64840 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
64844 beg = s.pending;
64846 if (s.pending === s.pending_buf_size) {
64851 put_byte(s, s.gzhead.extra[s.gzindex] & 0xff);
64852 s.gzindex++;
64855 if (s.gzhead.hcrc && s.pending > beg) {
64856 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
64859 if (s.gzindex === s.gzhead.extra.length) {
64860 s.gzindex = 0;
64861 s.status = NAME_STATE;
64864 s.status = NAME_STATE;
64868 if (s.status === NAME_STATE) {
64869 if (s.gzhead.name
64872 beg = s.pending;
64877 if (s.pending === s.pending_buf_size) {
64878 if (s.gzhead.hcrc && s.pending > beg) {
64879 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
64883 beg = s.pending;
64885 if (s.pending === s.pending_buf_size) {
64892 if (s.gzindex < s.gzhead.name.length) {
64893 val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff;
64898 put_byte(s, val);
64901 if (s.gzhead.hcrc && s.pending > beg) {
64902 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
64906 s.gzindex = 0;
64907 s.status = COMMENT_STATE;
64910 s.status = COMMENT_STATE;
64914 if (s.status === COMMENT_STATE) {
64915 if (s.gzhead.comment
64918 beg = s.pending;
64923 if (s.pending === s.pending_buf_size) {
64924 if (s.gzhead.hcrc && s.pending > beg) {
64925 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
64929 beg = s.pending;
64931 if (s.pending === s.pending_buf_size) {
64938 if (s.gzindex < s.gzhead.comment.length) {
64939 val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff;
64944 put_byte(s, val);
64947 if (s.gzhead.hcrc && s.pending > beg) {
64948 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
64952 s.status = HCRC_STATE;
64955 s.status = HCRC_STATE;
64959 if (s.status === HCRC_STATE) {
64960 if (s.gzhead.hcrc) {
64961 if (s.pending + 2 > s.pending_buf_size) {
64965 if (s.pending + 2 <= s.pending_buf_size) {
64966 put_byte(s, strm.adler & 0xff);
64967 put_byte(s, strm.adler >> 8 & 0xff);
64970 s.status = BUSY_STATE;
64973 s.status = BUSY_STATE;
64980 if (s.pending !== 0) {
64990 s.last_flush = -1;
65004 if (s.status === FINISH_STATE && strm.avail_in !== 0) {
65011 …if (strm.avail_in !== 0 || s.lookahead !== 0 || flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)…
65012 …tate = s.strategy === Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : s.strategy === Z_RLE ? deflate_rle…
65015 s.status = FINISH_STATE;
65020 s.last_flush = -1;
65036 trees._tr_align(s);
65039 trees._tr_stored_block(s, 0, 0, false);
65049 zero(s.head); // Fill with NIL (= 0);
65051 if (s.lookahead === 0) {
65052 s.strstart = 0;
65053 s.block_start = 0;
65054 s.insert = 0;
65062 s.last_flush = -1;
65076 if (s.wrap <= 0) {
65082 if (s.wrap === 2) {
65083 put_byte(s, strm.adler & 0xff);
65084 put_byte(s, strm.adler >> 8 & 0xff);
65085 put_byte(s, strm.adler >> 16 & 0xff);
65086 put_byte(s, strm.adler >> 24 & 0xff);
65087 put_byte(s, strm.total_in & 0xff);
65088 put_byte(s, strm.total_in >> 8 & 0xff);
65089 put_byte(s, strm.total_in >> 16 & 0xff);
65090 put_byte(s, strm.total_in >> 24 & 0xff);
65092 putShortMSB(s, strm.adler >>> 16);
65093 putShortMSB(s, strm.adler & 0xffff);
65101 if (s.wrap > 0) {
65102 s.wrap = -s.wrap;
65107 return s.pending !== 0 ? Z_OK : Z_STREAM_END;
65138 var s;
65154 s = strm.state;
65155 wrap = s.wrap;
65157 if (wrap === 2 || wrap === 1 && s.status !== INIT_STATE || s.lookahead) {
65168 s.wrap = 0;
65173 if (dictLength >= s.w_size) {
65178 zero(s.head); // Fill with NIL (= 0);
65180 s.strstart = 0;
65181 s.block_start = 0;
65182 s.insert = 0;
65188 tmpDict = new utils.Buf8(s.w_size);
65189 utils.arraySet(tmpDict, dictionary, dictLength - s.w_size, s.w_size, 0);
65191 dictLength = s.w_size;
65202 fill_window(s);
65204 while (s.lookahead >= MIN_MATCH) {
65205 str = s.strstart;
65206 n = s.lookahead - (MIN_MATCH - 1);
65210 s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;
65211 s.prev[str & s.w_mask] = s.head[s.ins_h];
65212 s.head[s.ins_h] = str;
65216 s.strstart = str;
65217 s.lookahead = MIN_MATCH - 1;
65218 fill_window(s);
65221 s.strstart += s.lookahead;
65222 s.block_start = s.strstart;
65223 s.insert = s.lookahead;
65224 s.lookahead = 0;
65225 s.match_length = s.prev_length = MIN_MATCH - 1;
65226 s.match_available = 0;
65230 s.wrap = wrap;
68573 function put_short(s, w) {
68576 s.pending_buf[s.pending++] = w & 0xff;
68577 s.pending_buf[s.pending++] = w >>> 8 & 0xff;
68585 function send_bits(s, value, length) {
68586 if (s.bi_valid > Buf_size - length) {
68587 s.bi_buf |= value << s.bi_valid & 0xffff;
68588 put_short(s, s.bi_buf);
68589 s.bi_buf = value >> Buf_size - s.bi_valid;
68590 s.bi_valid += length - Buf_size;
68592 s.bi_buf |= value << s.bi_valid & 0xffff;
68593 s.bi_valid += length;
68597 function send_code(s, c, tree) {
68598 send_bits(s, tree[c * 2]
68627 function bi_flush(s) {
68628 if (s.bi_valid === 16) {
68629 put_short(s, s.bi_buf);
68630 s.bi_buf = 0;
68631 s.bi_valid = 0;
68632 } else if (s.bi_valid >= 8) {
68633 s.pending_buf[s.pending++] = s.bi_buf & 0xff;
68634 s.bi_buf >>= 8;
68635 s.bi_valid -= 8;
68650 function gen_bitlen(s, desc) // deflate_state *s;
68679 s.bl_count[bits] = 0;
68686 tree[s.heap[s.heap_max] * 2 + 1]
68691 for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {
68692 n = s.heap[h];
68715 s.bl_count[bits]++;
68725 s.opt_len += f * (bits + xbits);
68728 s.static_len += f * (stree[n * 2 + 1]
68746 while (s.bl_count[bits] === 0) {
68750 s.bl_count[bits]--;
68753 s.bl_count[bits + 1] += 2;
68756 s.bl_count[max_length]--;
68771 n = s.bl_count[bits];
68774 m = s.heap[--h];
68784 s.opt_len += (bits - tree[m * 2 + 1]
69003 function init_block(s) {
69010 s.dyn_ltree[n * 2]
69016 s.dyn_dtree[n * 2]
69022 s.bl_tree[n * 2]
69027 s.dyn_ltree[END_BLOCK * 2]
69030 s.opt_len = s.static_len = 0;
69031 s.last_lit = s.matches = 0;
69038 function bi_windup(s) {
69039 if (s.bi_valid > 8) {
69040 put_short(s, s.bi_buf);
69041 } else if (s.bi_valid > 0) {
69043 s.pending_buf[s.pending++] = s.bi_buf;
69046 s.bi_buf = 0;
69047 s.bi_valid = 0;
69055 function copy_block(s, buf, len, header) //DeflateState *s;
69060 bi_windup(s);
69064 put_short(s, len);
69065 put_short(s, ~len);
69071 utils.arraySet(s.pending_buf, s.window, buf, len, s.pending);
69072 s.pending += len;
69103 function pqdownheap(s, tree, k) // deflate_state *s;
69107 var v = s.heap[k];
69111 while (j <= s.heap_len) {
69113 if (j < s.heap_len && smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {
69119 if (smaller(tree, v, s.heap[j], s.depth)) {
69125 s.heap[k] = s.heap[j];
69132 s.heap[k] = v;
69141 function compress_block(s, ltree, dtree) // deflate_state *s;
69160 if (s.last_lit !== 0) {
69162 dist = s.pending_buf[s.d_buf + lx * 2] << 8 | s.pending_buf[s.d_buf + lx * 2 + 1];
69163 lc = s.pending_buf[s.l_buf + lx];
69167 send_code(s, lc, ltree);
69173 send_code(s, code + LITERALS + 1, ltree);
69180 send_bits(s, lc, extra);
69189 send_code(s, code, dtree);
69196 send_bits(s, dist, extra);
69206 } while (lx < s.last_lit);
69209 send_code(s, END_BLOCK, ltree);
69221 function build_tree(s, desc) // deflate_state *s;
69242 s.heap_len = 0;
69243 s.heap_max = HEAP_SIZE;
69249 s.heap[++s.heap_len] = max_code = n;
69250 s.depth[n] = 0;
69264 while (s.heap_len < 2) {
69265 node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0;
69269 s.depth[node] = 0;
69270 s.opt_len--;
69273 s.static_len -= stree[node * 2 + 1]
69286 for (n = s.heap_len >> 1
69289 pqdownheap(s, tree, n);
69303 n = s.heap[1
69306 s.heap[1
69308 ] = s.heap[s.heap_len--];
69309 pqdownheap(s, tree, 1
69314 m = s.heap[1
69319 s.heap[--s.heap_max] = n;
69322 s.heap[--s.heap_max] = m;
69332 s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
69340 s.heap[1
69343 pqdownheap(s, tree, 1
69346 } while (s.heap_len >= 2);
69348 s.heap[--s.heap_max] = s.heap[1
69355 gen_bitlen(s, desc);
69358 gen_codes(tree, max_code, s.bl_count);
69366 function scan_tree(s, tree, max_code) // deflate_state *s;
69412 s.bl_tree[curlen * 2]
69417 s.bl_tree[curlen * 2] /*.Freq*/++;
69420 s.bl_tree[REP_3_6 * 2] /*.Freq*/++;
69422 s.bl_tree[REPZ_3_10 * 2] /*.Freq*/++;
69424 s.bl_tree[REPZ_11_138 * 2] /*.Freq*/++;
69448 function send_tree(s, tree, max_code) // deflate_state *s;
69494 send_code(s, curlen, s.bl_tree);
69498 send_code(s, curlen, s.bl_tree);
69503 send_code(s, REP_3_6, s.bl_tree);
69504 send_bits(s, count - 3, 2);
69506 send_code(s, REPZ_3_10, s.bl_tree);
69507 send_bits(s, count - 3, 3);
69509 send_code(s, REPZ_11_138, s.bl_tree);
69510 send_bits(s, count - 11, 7);
69534 function build_bl_tree(s) {
69540 scan_tree(s, s.dyn_ltree, s.l_desc.max_code);
69541 scan_tree(s, s.dyn_dtree, s.d_desc.max_code);
69544 build_tree(s, s.bl_desc);
69555 if (s.bl_tree[bl_order[max_blindex] * 2 + 1]
69564 …s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; //Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
69576 function send_all_trees(s, lcodes, dcodes, blcodes) // deflate_state *s;
69586 send_bits(s, lcodes - 257, 5);
69589 send_bits(s, dcodes - 1, 5);
69590 send_bits(s, blcodes - 4, 4);
69595 send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1]
69601 send_tree(s, s.dyn_ltree, lcodes - 1);
69605 send_tree(s, s.dyn_dtree, dcodes - 1);
69624 function detect_data_type(s) {
69634 if (black_mask & 1 && s.dyn_ltree[n * 2]
69643 if (s.dyn_ltree[9 * 2]
69645 !== 0 || s.dyn_ltree[10 * 2]
69647 !== 0 || s.dyn_ltree[13 * 2]
69654 if (s.dyn_ltree[n * 2]
69673 function _tr_init(s) {
69679 s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc);
69680 s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc);
69681 s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);
69682 s.bi_buf = 0;
69683 s.bi_valid = 0;
69686 init_block(s);
69693 function _tr_stored_block(s, buf, stored_len, last) //DeflateState *s;
69698 send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3);
69701 copy_block(s, buf, stored_len, true);
69710 function _tr_align(s) {
69711 send_bits(s, STATIC_TREES << 1, 3);
69712 send_code(s, END_BLOCK, static_ltree);
69713 bi_flush(s);
69721 function _tr_flush_block(s, buf, stored_len, last) //DeflateState *s;
69734 if (s.level > 0) {
69736 if (s.strm.data_type === Z_UNKNOWN) {
69737 s.strm.data_type = detect_data_type(s);
69742 build_tree(s, s.l_desc); // Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
69745 build_tree(s, s.d_desc); // Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
69756 max_blindex = build_bl_tree(s);
69759 opt_lenb = s.opt_len + 3 + 7 >>> 3;
69760 …static_lenb = s.static_len + 3 + 7 >>> 3; // Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored …
69782 _tr_stored_block(s, buf, stored_len, last);
69783 } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {
69784 send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);
69785 compress_block(s, static_ltree, static_dtree);
69787 send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);
69788 send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);
69789 compress_block(s, s.dyn_ltree, s.dyn_dtree);
69797 init_block(s);
69800 bi_windup(s);
69811 function _tr_tally(s, dist, lc) // deflate_state *s;
69816 s.pending_buf[s.d_buf + s.last_lit * 2] = dist >>> 8 & 0xff;
69817 s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff;
69818 s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff;
69819 s.last_lit++;
69823 s.dyn_ltree[lc * 2] /*.Freq*/++;
69825 s.matches++;
69834 s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2] /*.Freq*/++;
69835 s.dyn_dtree[d_code(dist) * 2] /*.Freq*/++;
69859 return s.last_lit === s.lit_bufsize - 1;
74014 value: function join(s) {
74020 ret += s + p.data;
75370 function fn1(a, b, c, d, e, m, k, s) {
75371 return rotl(a + (b ^ c ^ d) + m + k | 0, s) + e | 0;
75374 function fn2(a, b, c, d, e, m, k, s) {
75375 return rotl(a + (b & c | ~b & d) + m + k | 0, s) + e | 0;
75378 function fn3(a, b, c, d, e, m, k, s) {
75379 return rotl(a + ((b | ~c) ^ d) + m + k | 0, s) + e | 0;
75382 function fn4(a, b, c, d, e, m, k, s) {
75383 return rotl(a + (b & d | c & ~d) + m + k | 0, s) + e | 0;
75386 function fn5(a, b, c, d, e, m, k, s) {
75387 return rotl(a + (b ^ (c | ~d)) + m + k | 0, s) + e | 0;
75557 …s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i…
77879 for (_iterator.s(); !(_step = _iterator.n()).done;) {
77931 for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
78280 function ft(s, b, c, d) {
78281 if (s === 0) return b & c | ~b & d;
78282 if (s === 2) return b & c | b & d | c & d;
78303 var s = ~~(j / 20);
78304 var t = rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s] | 0;
78380 function ft(s, b, c, d) {
78381 if (s === 0) return b & c | ~b & d;
78382 if (s === 2) return b & c | b & d | c & d;
78403 var s = ~~(j / 20);
78404 var t = rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s] | 0;
81160 BufferList.prototype.join = function join(s) {
81166 ret += s + p.data;
82729 function md5cmn(q, a, b, x, s, t) {
82730 return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);
82733 function md5ff(a, b, c, d, x, s, t) {
82734 return md5cmn(b & c | ~b & d, a, b, x, s, t);
82737 function md5gg(a, b, c, d, x, s, t) {
82738 return md5cmn(b & d | c & ~d, a, b, x, s, t);
82741 function md5hh(a, b, c, d, x, s, t) {
82742 return md5cmn(b ^ c ^ d, a, b, x, s, t);
82745 function md5ii(a, b, c, d, x, s, t) {
82746 return md5cmn(c ^ (b | ~d), a, b, x, s, t);
82855 function f(s, x, y, z) {
82856 switch (s) {
82929 var s = Math.floor(_t2 / 20);
82930 var T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[_t2] >>> 0;