Initial import
[darksolar] / node_modules / mongoose / node_modules / mongodb / node_modules / bson / lib / bson / long.js
1 // Licensed under the Apache License, Version 2.0 (the "License");
2 // you may not use this file except in compliance with the License.
3 // You may obtain a copy of the License at
4 //
5 //     http://www.apache.org/licenses/LICENSE-2.0
6 //
7 // Unless required by applicable law or agreed to in writing, software
8 // distributed under the License is distributed on an "AS IS" BASIS,
9 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 // See the License for the specific language governing permissions and
11 // limitations under the License.
12 //
13 // Copyright 2009 Google Inc. All Rights Reserved
14
15 /**
16  * Defines a Long class for representing a 64-bit two's-complement
17  * integer value, which faithfully simulates the behavior of a Java "Long". This
18  * implementation is derived from LongLib in GWT.
19  *
20  * Constructs a 64-bit two's-complement integer, given its low and high 32-bit
21  * values as *signed* integers.  See the from* functions below for more
22  * convenient ways of constructing Longs.
23  *
24  * The internal representation of a Long is the two given signed, 32-bit values.
25  * We use 32-bit pieces because these are the size of integers on which
26  * Javascript performs bit-operations.  For operations like addition and
27  * multiplication, we split each number into 16-bit pieces, which can easily be
28  * multiplied within Javascript's floating-point representation without overflow
29  * or change in sign.
30  *
31  * In the algorithms below, we frequently reduce the negative case to the
32  * positive case by negating the input(s) and then post-processing the result.
33  * Note that we must ALWAYS check specially whether those values are MIN_VALUE
34  * (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as
35  * a positive number, it overflows back into a negative).  Not handling this
36  * case would often result in infinite recursion.
37  *
38  * @class Represents the BSON Long type.
39  * @param {Number} low  the low (signed) 32 bits of the Long.
40  * @param {Number} high the high (signed) 32 bits of the Long.
41  */
42 function Long(low, high) {
43   if(!(this instanceof Long)) return new Long(low, high);
44   
45   this._bsontype = 'Long';
46   /**
47    * @type {number}
48    * @api private
49    */
50   this.low_ = low | 0;  // force into 32 signed bits.
51
52   /**
53    * @type {number}
54    * @api private
55    */
56   this.high_ = high | 0;  // force into 32 signed bits.
57 };
58
59 /**
60  * Return the int value.
61  *
62  * @return {Number} the value, assuming it is a 32-bit integer.
63  * @api public
64  */
65 Long.prototype.toInt = function() {
66   return this.low_;
67 };
68
69 /**
70  * Return the Number value.
71  *
72  * @return {Number} the closest floating-point representation to this value.
73  * @api public
74  */
75 Long.prototype.toNumber = function() {
76   return this.high_ * Long.TWO_PWR_32_DBL_ +
77          this.getLowBitsUnsigned();
78 };
79
80 /**
81  * Return the JSON value.
82  *
83  * @return {String} the JSON representation.
84  * @api public
85  */
86 Long.prototype.toJSON = function() {
87   return this.toString();
88 }
89
90 /**
91  * Return the String value.
92  *
93  * @param {Number} [opt_radix] the radix in which the text should be written.
94  * @return {String} the textual representation of this value.
95  * @api public
96  */
97 Long.prototype.toString = function(opt_radix) {
98   var radix = opt_radix || 10;
99   if (radix < 2 || 36 < radix) {
100     throw Error('radix out of range: ' + radix);
101   }
102
103   if (this.isZero()) {
104     return '0';
105   }
106
107   if (this.isNegative()) {
108     if (this.equals(Long.MIN_VALUE)) {
109       // We need to change the Long value before it can be negated, so we remove
110       // the bottom-most digit in this base and then recurse to do the rest.
111       var radixLong = Long.fromNumber(radix);
112       var div = this.div(radixLong);
113       var rem = div.multiply(radixLong).subtract(this);
114       return div.toString(radix) + rem.toInt().toString(radix);
115     } else {
116       return '-' + this.negate().toString(radix);
117     }
118   }
119
120   // Do several (6) digits each time through the loop, so as to
121   // minimize the calls to the very expensive emulated div.
122   var radixToPower = Long.fromNumber(Math.pow(radix, 6));
123
124   var rem = this;
125   var result = '';
126   while (true) {
127     var remDiv = rem.div(radixToPower);
128     var intval = rem.subtract(remDiv.multiply(radixToPower)).toInt();
129     var digits = intval.toString(radix);
130
131     rem = remDiv;
132     if (rem.isZero()) {
133       return digits + result;
134     } else {
135       while (digits.length < 6) {
136         digits = '0' + digits;
137       }
138       result = '' + digits + result;
139     }
140   }
141 };
142
143 /**
144  * Return the high 32-bits value.
145  *
146  * @return {Number} the high 32-bits as a signed value.
147  * @api public
148  */
149 Long.prototype.getHighBits = function() {
150   return this.high_;
151 };
152
153 /**
154  * Return the low 32-bits value.
155  *
156  * @return {Number} the low 32-bits as a signed value.
157  * @api public
158  */
159 Long.prototype.getLowBits = function() {
160   return this.low_;
161 };
162
163 /**
164  * Return the low unsigned 32-bits value.
165  *
166  * @return {Number} the low 32-bits as an unsigned value.
167  * @api public
168  */
169 Long.prototype.getLowBitsUnsigned = function() {
170   return (this.low_ >= 0) ?
171       this.low_ : Long.TWO_PWR_32_DBL_ + this.low_;
172 };
173
174 /**
175  * Returns the number of bits needed to represent the absolute value of this Long.
176  *
177  * @return {Number} Returns the number of bits needed to represent the absolute value of this Long.
178  * @api public
179  */
180 Long.prototype.getNumBitsAbs = function() {
181   if (this.isNegative()) {
182     if (this.equals(Long.MIN_VALUE)) {
183       return 64;
184     } else {
185       return this.negate().getNumBitsAbs();
186     }
187   } else {
188     var val = this.high_ != 0 ? this.high_ : this.low_;
189     for (var bit = 31; bit > 0; bit--) {
190       if ((val & (1 << bit)) != 0) {
191         break;
192       }
193     }
194     return this.high_ != 0 ? bit + 33 : bit + 1;
195   }
196 };
197
198 /**
199  * Return whether this value is zero.
200  *
201  * @return {Boolean} whether this value is zero.
202  * @api public
203  */
204 Long.prototype.isZero = function() {
205   return this.high_ == 0 && this.low_ == 0;
206 };
207
208 /**
209  * Return whether this value is negative.
210  *
211  * @return {Boolean} whether this value is negative.
212  * @api public
213  */
214 Long.prototype.isNegative = function() {
215   return this.high_ < 0;
216 };
217
218 /**
219  * Return whether this value is odd.
220  *
221  * @return {Boolean} whether this value is odd.
222  * @api public
223  */
224 Long.prototype.isOdd = function() {
225   return (this.low_ & 1) == 1;
226 };
227
228 /**
229  * Return whether this Long equals the other
230  *
231  * @param {Long} other Long to compare against.
232  * @return {Boolean} whether this Long equals the other
233  * @api public
234  */
235 Long.prototype.equals = function(other) {
236   return (this.high_ == other.high_) && (this.low_ == other.low_);
237 };
238
239 /**
240  * Return whether this Long does not equal the other.
241  *
242  * @param {Long} other Long to compare against.
243  * @return {Boolean} whether this Long does not equal the other.
244  * @api public
245  */
246 Long.prototype.notEquals = function(other) {
247   return (this.high_ != other.high_) || (this.low_ != other.low_);
248 };
249
250 /**
251  * Return whether this Long is less than the other.
252  *
253  * @param {Long} other Long to compare against.
254  * @return {Boolean} whether this Long is less than the other.
255  * @api public
256  */
257 Long.prototype.lessThan = function(other) {
258   return this.compare(other) < 0;
259 };
260
261 /**
262  * Return whether this Long is less than or equal to the other.
263  *
264  * @param {Long} other Long to compare against.
265  * @return {Boolean} whether this Long is less than or equal to the other.
266  * @api public
267  */
268 Long.prototype.lessThanOrEqual = function(other) {
269   return this.compare(other) <= 0;
270 };
271
272 /**
273  * Return whether this Long is greater than the other.
274  *
275  * @param {Long} other Long to compare against.
276  * @return {Boolean} whether this Long is greater than the other.
277  * @api public
278  */
279 Long.prototype.greaterThan = function(other) {
280   return this.compare(other) > 0;
281 };
282
283 /**
284  * Return whether this Long is greater than or equal to the other.
285  *
286  * @param {Long} other Long to compare against.
287  * @return {Boolean} whether this Long is greater than or equal to the other.
288  * @api public
289  */
290 Long.prototype.greaterThanOrEqual = function(other) {
291   return this.compare(other) >= 0;
292 };
293
294 /**
295  * Compares this Long with the given one.
296  *
297  * @param {Long} other Long to compare against.
298  * @return {Boolean} 0 if they are the same, 1 if the this is greater, and -1 if the given one is greater.
299  * @api public
300  */
301 Long.prototype.compare = function(other) {
302   if (this.equals(other)) {
303     return 0;
304   }
305
306   var thisNeg = this.isNegative();
307   var otherNeg = other.isNegative();
308   if (thisNeg && !otherNeg) {
309     return -1;
310   }
311   if (!thisNeg && otherNeg) {
312     return 1;
313   }
314
315   // at this point, the signs are the same, so subtraction will not overflow
316   if (this.subtract(other).isNegative()) {
317     return -1;
318   } else {
319     return 1;
320   }
321 };
322
323 /**
324  * The negation of this value.
325  *
326  * @return {Long} the negation of this value.
327  * @api public
328  */
329 Long.prototype.negate = function() {
330   if (this.equals(Long.MIN_VALUE)) {
331     return Long.MIN_VALUE;
332   } else {
333     return this.not().add(Long.ONE);
334   }
335 };
336
337 /**
338  * Returns the sum of this and the given Long.
339  *
340  * @param {Long} other Long to add to this one.
341  * @return {Long} the sum of this and the given Long.
342  * @api public
343  */
344 Long.prototype.add = function(other) {
345   // Divide each number into 4 chunks of 16 bits, and then sum the chunks.
346
347   var a48 = this.high_ >>> 16;
348   var a32 = this.high_ & 0xFFFF;
349   var a16 = this.low_ >>> 16;
350   var a00 = this.low_ & 0xFFFF;
351
352   var b48 = other.high_ >>> 16;
353   var b32 = other.high_ & 0xFFFF;
354   var b16 = other.low_ >>> 16;
355   var b00 = other.low_ & 0xFFFF;
356
357   var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
358   c00 += a00 + b00;
359   c16 += c00 >>> 16;
360   c00 &= 0xFFFF;
361   c16 += a16 + b16;
362   c32 += c16 >>> 16;
363   c16 &= 0xFFFF;
364   c32 += a32 + b32;
365   c48 += c32 >>> 16;
366   c32 &= 0xFFFF;
367   c48 += a48 + b48;
368   c48 &= 0xFFFF;
369   return Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
370 };
371
372 /**
373  * Returns the difference of this and the given Long.
374  *
375  * @param {Long} other Long to subtract from this.
376  * @return {Long} the difference of this and the given Long.
377  * @api public
378  */
379 Long.prototype.subtract = function(other) {
380   return this.add(other.negate());
381 };
382
383 /**
384  * Returns the product of this and the given Long.
385  *
386  * @param {Long} other Long to multiply with this.
387  * @return {Long} the product of this and the other.
388  * @api public
389  */
390 Long.prototype.multiply = function(other) {
391   if (this.isZero()) {
392     return Long.ZERO;
393   } else if (other.isZero()) {
394     return Long.ZERO;
395   }
396
397   if (this.equals(Long.MIN_VALUE)) {
398     return other.isOdd() ? Long.MIN_VALUE : Long.ZERO;
399   } else if (other.equals(Long.MIN_VALUE)) {
400     return this.isOdd() ? Long.MIN_VALUE : Long.ZERO;
401   }
402
403   if (this.isNegative()) {
404     if (other.isNegative()) {
405       return this.negate().multiply(other.negate());
406     } else {
407       return this.negate().multiply(other).negate();
408     }
409   } else if (other.isNegative()) {
410     return this.multiply(other.negate()).negate();
411   }
412
413   // If both Longs are small, use float multiplication
414   if (this.lessThan(Long.TWO_PWR_24_) &&
415       other.lessThan(Long.TWO_PWR_24_)) {
416     return Long.fromNumber(this.toNumber() * other.toNumber());
417   }
418
419   // Divide each Long into 4 chunks of 16 bits, and then add up 4x4 products.
420   // We can skip products that would overflow.
421
422   var a48 = this.high_ >>> 16;
423   var a32 = this.high_ & 0xFFFF;
424   var a16 = this.low_ >>> 16;
425   var a00 = this.low_ & 0xFFFF;
426
427   var b48 = other.high_ >>> 16;
428   var b32 = other.high_ & 0xFFFF;
429   var b16 = other.low_ >>> 16;
430   var b00 = other.low_ & 0xFFFF;
431
432   var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
433   c00 += a00 * b00;
434   c16 += c00 >>> 16;
435   c00 &= 0xFFFF;
436   c16 += a16 * b00;
437   c32 += c16 >>> 16;
438   c16 &= 0xFFFF;
439   c16 += a00 * b16;
440   c32 += c16 >>> 16;
441   c16 &= 0xFFFF;
442   c32 += a32 * b00;
443   c48 += c32 >>> 16;
444   c32 &= 0xFFFF;
445   c32 += a16 * b16;
446   c48 += c32 >>> 16;
447   c32 &= 0xFFFF;
448   c32 += a00 * b32;
449   c48 += c32 >>> 16;
450   c32 &= 0xFFFF;
451   c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
452   c48 &= 0xFFFF;
453   return Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
454 };
455
456 /**
457  * Returns this Long divided by the given one.
458  *
459  * @param {Long} other Long by which to divide.
460  * @return {Long} this Long divided by the given one.
461  * @api public
462  */
463 Long.prototype.div = function(other) {
464   if (other.isZero()) {
465     throw Error('division by zero');
466   } else if (this.isZero()) {
467     return Long.ZERO;
468   }
469
470   if (this.equals(Long.MIN_VALUE)) {
471     if (other.equals(Long.ONE) ||
472         other.equals(Long.NEG_ONE)) {
473       return Long.MIN_VALUE;  // recall that -MIN_VALUE == MIN_VALUE
474     } else if (other.equals(Long.MIN_VALUE)) {
475       return Long.ONE;
476     } else {
477       // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.
478       var halfThis = this.shiftRight(1);
479       var approx = halfThis.div(other).shiftLeft(1);
480       if (approx.equals(Long.ZERO)) {
481         return other.isNegative() ? Long.ONE : Long.NEG_ONE;
482       } else {
483         var rem = this.subtract(other.multiply(approx));
484         var result = approx.add(rem.div(other));
485         return result;
486       }
487     }
488   } else if (other.equals(Long.MIN_VALUE)) {
489     return Long.ZERO;
490   }
491
492   if (this.isNegative()) {
493     if (other.isNegative()) {
494       return this.negate().div(other.negate());
495     } else {
496       return this.negate().div(other).negate();
497     }
498   } else if (other.isNegative()) {
499     return this.div(other.negate()).negate();
500   }
501
502   // Repeat the following until the remainder is less than other:  find a
503   // floating-point that approximates remainder / other *from below*, add this
504   // into the result, and subtract it from the remainder.  It is critical that
505   // the approximate value is less than or equal to the real value so that the
506   // remainder never becomes negative.
507   var res = Long.ZERO;
508   var rem = this;
509   while (rem.greaterThanOrEqual(other)) {
510     // Approximate the result of division. This may be a little greater or
511     // smaller than the actual value.
512     var approx = Math.max(1, Math.floor(rem.toNumber() / other.toNumber()));
513
514     // We will tweak the approximate result by changing it in the 48-th digit or
515     // the smallest non-fractional digit, whichever is larger.
516     var log2 = Math.ceil(Math.log(approx) / Math.LN2);
517     var delta = (log2 <= 48) ? 1 : Math.pow(2, log2 - 48);
518
519     // Decrease the approximation until it is smaller than the remainder.  Note
520     // that if it is too large, the product overflows and is negative.
521     var approxRes = Long.fromNumber(approx);
522     var approxRem = approxRes.multiply(other);
523     while (approxRem.isNegative() || approxRem.greaterThan(rem)) {
524       approx -= delta;
525       approxRes = Long.fromNumber(approx);
526       approxRem = approxRes.multiply(other);
527     }
528
529     // We know the answer can't be zero... and actually, zero would cause
530     // infinite recursion since we would make no progress.
531     if (approxRes.isZero()) {
532       approxRes = Long.ONE;
533     }
534
535     res = res.add(approxRes);
536     rem = rem.subtract(approxRem);
537   }
538   return res;
539 };
540
541 /**
542  * Returns this Long modulo the given one.
543  *
544  * @param {Long} other Long by which to mod.
545  * @return {Long} this Long modulo the given one.
546  * @api public
547  */
548 Long.prototype.modulo = function(other) {
549   return this.subtract(this.div(other).multiply(other));
550 };
551
552 /**
553  * The bitwise-NOT of this value.
554  *
555  * @return {Long} the bitwise-NOT of this value.
556  * @api public
557  */
558 Long.prototype.not = function() {
559   return Long.fromBits(~this.low_, ~this.high_);
560 };
561
562 /**
563  * Returns the bitwise-AND of this Long and the given one.
564  *
565  * @param {Long} other the Long with which to AND.
566  * @return {Long} the bitwise-AND of this and the other.
567  * @api public
568  */
569 Long.prototype.and = function(other) {
570   return Long.fromBits(this.low_ & other.low_, this.high_ & other.high_);
571 };
572
573 /**
574  * Returns the bitwise-OR of this Long and the given one.
575  *
576  * @param {Long} other the Long with which to OR.
577  * @return {Long} the bitwise-OR of this and the other.
578  * @api public
579  */
580 Long.prototype.or = function(other) {
581   return Long.fromBits(this.low_ | other.low_, this.high_ | other.high_);
582 };
583
584 /**
585  * Returns the bitwise-XOR of this Long and the given one.
586  *
587  * @param {Long} other the Long with which to XOR.
588  * @return {Long} the bitwise-XOR of this and the other.
589  * @api public
590  */
591 Long.prototype.xor = function(other) {
592   return Long.fromBits(this.low_ ^ other.low_, this.high_ ^ other.high_);
593 };
594
595 /**
596  * Returns this Long with bits shifted to the left by the given amount.
597  *
598  * @param {Number} numBits the number of bits by which to shift.
599  * @return {Long} this shifted to the left by the given amount.
600  * @api public
601  */
602 Long.prototype.shiftLeft = function(numBits) {
603   numBits &= 63;
604   if (numBits == 0) {
605     return this;
606   } else {
607     var low = this.low_;
608     if (numBits < 32) {
609       var high = this.high_;
610       return Long.fromBits(
611                  low << numBits,
612                  (high << numBits) | (low >>> (32 - numBits)));
613     } else {
614       return Long.fromBits(0, low << (numBits - 32));
615     }
616   }
617 };
618
619 /**
620  * Returns this Long with bits shifted to the right by the given amount.
621  *
622  * @param {Number} numBits the number of bits by which to shift.
623  * @return {Long} this shifted to the right by the given amount.
624  * @api public
625  */
626 Long.prototype.shiftRight = function(numBits) {
627   numBits &= 63;
628   if (numBits == 0) {
629     return this;
630   } else {
631     var high = this.high_;
632     if (numBits < 32) {
633       var low = this.low_;
634       return Long.fromBits(
635                  (low >>> numBits) | (high << (32 - numBits)),
636                  high >> numBits);
637     } else {
638       return Long.fromBits(
639                  high >> (numBits - 32),
640                  high >= 0 ? 0 : -1);
641     }
642   }
643 };
644
645 /**
646  * Returns this Long with bits shifted to the right by the given amount, with the new top bits matching the current sign bit.
647  *
648  * @param {Number} numBits the number of bits by which to shift.
649  * @return {Long} this shifted to the right by the given amount, with zeros placed into the new leading bits.
650  * @api public
651  */
652 Long.prototype.shiftRightUnsigned = function(numBits) {
653   numBits &= 63;
654   if (numBits == 0) {
655     return this;
656   } else {
657     var high = this.high_;
658     if (numBits < 32) {
659       var low = this.low_;
660       return Long.fromBits(
661                  (low >>> numBits) | (high << (32 - numBits)),
662                  high >>> numBits);
663     } else if (numBits == 32) {
664       return Long.fromBits(high, 0);
665     } else {
666       return Long.fromBits(high >>> (numBits - 32), 0);
667     }
668   }
669 };
670
671 /**
672  * Returns a Long representing the given (32-bit) integer value.
673  *
674  * @param {Number} value the 32-bit integer in question.
675  * @return {Long} the corresponding Long value.
676  * @api public
677  */
678 Long.fromInt = function(value) {
679   if (-128 <= value && value < 128) {
680     var cachedObj = Long.INT_CACHE_[value];
681     if (cachedObj) {
682       return cachedObj;
683     }
684   }
685
686   var obj = new Long(value | 0, value < 0 ? -1 : 0);
687   if (-128 <= value && value < 128) {
688     Long.INT_CACHE_[value] = obj;
689   }
690   return obj;
691 };
692
693 /**
694  * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.
695  *
696  * @param {Number} value the number in question.
697  * @return {Long} the corresponding Long value.
698  * @api public
699  */
700 Long.fromNumber = function(value) {
701   if (isNaN(value) || !isFinite(value)) {
702     return Long.ZERO;
703   } else if (value <= -Long.TWO_PWR_63_DBL_) {
704     return Long.MIN_VALUE;
705   } else if (value + 1 >= Long.TWO_PWR_63_DBL_) {
706     return Long.MAX_VALUE;
707   } else if (value < 0) {
708     return Long.fromNumber(-value).negate();
709   } else {
710     return new Long(
711                (value % Long.TWO_PWR_32_DBL_) | 0,
712                (value / Long.TWO_PWR_32_DBL_) | 0);
713   }
714 };
715
716 /**
717  * Returns a Long representing the 64-bit integer that comes by concatenating the given high and low bits. Each is assumed to use 32 bits.
718  *
719  * @param {Number} lowBits the low 32-bits.
720  * @param {Number} highBits the high 32-bits.
721  * @return {Long} the corresponding Long value.
722  * @api public
723  */
724 Long.fromBits = function(lowBits, highBits) {
725   return new Long(lowBits, highBits);
726 };
727
728 /**
729  * Returns a Long representation of the given string, written using the given radix.
730  *
731  * @param {String} str the textual representation of the Long.
732  * @param {Number} opt_radix the radix in which the text is written.
733  * @return {Long} the corresponding Long value.
734  * @api public
735  */
736 Long.fromString = function(str, opt_radix) {
737   if (str.length == 0) {
738     throw Error('number format error: empty string');
739   }
740
741   var radix = opt_radix || 10;
742   if (radix < 2 || 36 < radix) {
743     throw Error('radix out of range: ' + radix);
744   }
745
746   if (str.charAt(0) == '-') {
747     return Long.fromString(str.substring(1), radix).negate();
748   } else if (str.indexOf('-') >= 0) {
749     throw Error('number format error: interior "-" character: ' + str);
750   }
751
752   // Do several (8) digits each time through the loop, so as to
753   // minimize the calls to the very expensive emulated div.
754   var radixToPower = Long.fromNumber(Math.pow(radix, 8));
755
756   var result = Long.ZERO;
757   for (var i = 0; i < str.length; i += 8) {
758     var size = Math.min(8, str.length - i);
759     var value = parseInt(str.substring(i, i + size), radix);
760     if (size < 8) {
761       var power = Long.fromNumber(Math.pow(radix, size));
762       result = result.multiply(power).add(Long.fromNumber(value));
763     } else {
764       result = result.multiply(radixToPower);
765       result = result.add(Long.fromNumber(value));
766     }
767   }
768   return result;
769 };
770
771 // NOTE: Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the
772 // from* methods on which they depend.
773
774
775 /**
776  * A cache of the Long representations of small integer values.
777  * @type {Object}
778  * @api private
779  */
780 Long.INT_CACHE_ = {};
781
782 // NOTE: the compiler should inline these constant values below and then remove
783 // these variables, so there should be no runtime penalty for these.
784
785 /**
786  * Number used repeated below in calculations.  This must appear before the
787  * first call to any from* function below.
788  * @type {number}
789  * @api private
790  */
791 Long.TWO_PWR_16_DBL_ = 1 << 16;
792
793 /**
794  * @type {number}
795  * @api private
796  */
797 Long.TWO_PWR_24_DBL_ = 1 << 24;
798
799 /**
800  * @type {number}
801  * @api private
802  */
803 Long.TWO_PWR_32_DBL_ = Long.TWO_PWR_16_DBL_ * Long.TWO_PWR_16_DBL_;
804
805 /**
806  * @type {number}
807  * @api private
808  */
809 Long.TWO_PWR_31_DBL_ = Long.TWO_PWR_32_DBL_ / 2;
810
811 /**
812  * @type {number}
813  * @api private
814  */
815 Long.TWO_PWR_48_DBL_ = Long.TWO_PWR_32_DBL_ * Long.TWO_PWR_16_DBL_;
816
817 /**
818  * @type {number}
819  * @api private
820  */
821 Long.TWO_PWR_64_DBL_ = Long.TWO_PWR_32_DBL_ * Long.TWO_PWR_32_DBL_;
822
823 /**
824  * @type {number}
825  * @api private
826  */
827 Long.TWO_PWR_63_DBL_ = Long.TWO_PWR_64_DBL_ / 2;
828
829 /** @type {Long} */
830 Long.ZERO = Long.fromInt(0);
831
832 /** @type {Long} */
833 Long.ONE = Long.fromInt(1);
834
835 /** @type {Long} */
836 Long.NEG_ONE = Long.fromInt(-1);
837
838 /** @type {Long} */
839 Long.MAX_VALUE =
840     Long.fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0);
841
842 /** @type {Long} */
843 Long.MIN_VALUE = Long.fromBits(0, 0x80000000 | 0);
844
845 /**
846  * @type {Long}
847  * @api private
848  */
849 Long.TWO_PWR_24_ = Long.fromInt(1 << 24);
850
851 /**
852  * Expose.
853  */
854 if(typeof window === 'undefined') {
855   exports.Long = Long;
856 }