Modules

node_modules/bytebuffer/node_modules/long/.npmignore

@@ -0,0 +1,3 @@
+node_modules
+npm-debug.log
+.idea/

node_modules/bytebuffer/node_modules/long/.travis.yml

@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - 0.12
+  - 4.2
+sudo: false

node_modules/bytebuffer/node_modules/long/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

node_modules/bytebuffer/node_modules/long/README.md

@@ -0,0 +1,513 @@
+![long.js - A Long class for representing a 64 bit two's-complement integer ](https://raw.github.com/dcodeIO/long.js/master/long.png)
+=======
+A Long class for representing a 64 bit two's-complement integer value derived from the [Closure Library](https://github.com/google/closure-library)
+for stand-alone use and extended with unsigned support.
+
+[![Build Status](https://travis-ci.org/dcodeIO/long.js.svg)](https://travis-ci.org/dcodeIO/long.js)
+[![Donate](https://raw.githubusercontent.com/dcodeIO/long.js/master/donate.png)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=dcode%40dcode.io&item_name=%3C3%20long.js)
+
+Background
+----------
+As of [ECMA-262 5th Edition](http://ecma262-5.com/ELS5_HTML.htm#Section_8.5), "all the positive and negative integers
+whose magnitude is no greater than 2<sup>53</sup> are representable in the Number type", which is "representing the
+doubleprecision 64-bit format IEEE 754 values as specified in the IEEE Standard for Binary Floating-Point Arithmetic".
+The [maximum safe integer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER)
+in JavaScript is 2<sup>53</sup>-1.
+
+Example: 2<sup>64</sup>-1 is 18446744073709551615 but in JavaScript it evaluates to `18446744073709552000`.
+
+Furthermore, bitwise operators in JavaScript "deal only with integers in the range −2<sup>31</sup> through
+2<sup>31</sup>−1, inclusive, or in the range 0 through 2<sup>32</sup>−1, inclusive. These operators accept any value of
+the Number type but first convert each such value to one of 2<sup>32</sup> integer values."
+
+In some use cases, however, it is required to be able to reliably work with and perform bitwise operations on the full
+64 bits. This is where long.js comes into play.
+
+Usage
+-----
+The class is compatible with CommonJS and AMD loaders and is exposed globally as `dcodeIO.Long` if neither is available.
+
+```javascript
+var Long = require("long");
+
+var longVal = new Long(0xFFFFFFFF, 0x7FFFFFFF);
+console.log(longVal.toString());
+...
+```
+
+API
+---
+
+#### new Long(low, high=, unsigned=)
+
+Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.
+See the from* functions below for more convenient ways of constructing Longs.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| low             | *number*        | The low (signed) 32 bits of the long 
+| high            | *number*        | The high (signed) 32 bits of the long 
+| unsigned        | *boolean*       | Whether unsigned or not, defaults to `false` for signed 
+
+---
+
+#### Long.MAX_UNSIGNED_VALUE
+
+Maximum unsigned value.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *!Long*         |
+
+#### Long.MAX_VALUE
+
+Maximum signed value.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *!Long*         |
+
+#### Long.MIN_VALUE
+
+Minimum signed value.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *!Long*         |
+
+#### Long.NEG_ONE
+
+Signed negative one.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *!Long*         |
+
+#### Long.ONE
+
+Signed one.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *!Long*         |
+
+#### Long.UONE
+
+Unsigned one.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *!Long*         |
+
+#### Long.UZERO
+
+Unsigned zero.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *!Long*         |
+
+#### Long.ZERO
+
+Signed zero.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *!Long*         |
+
+#### Long.fromBits(lowBits, highBits, unsigned=)
+
+Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is
+assumed to use 32 bits.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| lowBits         | *number*        | The low 32 bits 
+| highBits        | *number*        | The high 32 bits 
+| unsigned        | *boolean*       | Whether unsigned or not, defaults to `false` for signed 
+| **@returns**    | *!Long*         | The corresponding Long value 
+
+#### Long.fromInt(value, unsigned=)
+
+Returns a Long representing the given 32 bit integer value.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| value           | *number*        | The 32 bit integer in question 
+| unsigned        | *boolean*       | Whether unsigned or not, defaults to `false` for signed 
+| **@returns**    | *!Long*         | The corresponding Long value 
+
+#### Long.fromNumber(value, unsigned=)
+
+Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| value           | *number*        | The number in question 
+| unsigned        | *boolean*       | Whether unsigned or not, defaults to `false` for signed 
+| **@returns**    | *!Long*         | The corresponding Long value 
+
+#### Long.fromString(str, unsigned=, radix=)
+
+Returns a Long representation of the given string, written using the specified radix.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| str             | *string*        | The textual representation of the Long 
+| unsigned        | *boolean &#124; number* | Whether unsigned or not, defaults to `false` for signed 
+| radix           | *number*        | The radix in which the text is written (2-36), defaults to 10 
+| **@returns**    | *!Long*         | The corresponding Long value 
+
+#### Long.isLong(obj)
+
+Tests if the specified object is a Long.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| obj             | ***             | Object 
+| **@returns**    | *boolean*       | 
+
+#### Long.fromValue(val)
+
+Converts the specified value to a Long.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| val             | *!Long &#124; number &#124; string &#124; !{low: number, high: number, unsigned: boolean}* | Value 
+| **@returns**    | *!Long*         | 
+
+---
+
+#### Long#high
+
+The high 32 bits as a signed value.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *number*        |
+
+#### Long#low
+
+The low 32 bits as a signed value.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *number*        |
+
+#### Long#unsigned
+
+Whether unsigned or not.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *boolean*       |
+
+#### Long#add(addend)
+
+Returns the sum of this and the specified Long.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| addend          | *!Long &#124; number &#124; string* | Addend 
+| **@returns**    | *!Long*         | Sum 
+
+#### Long#and(other)
+
+Returns the bitwise AND of this Long and the specified.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long &#124; number &#124; string* | Other Long 
+| **@returns**    | *!Long*         | 
+
+#### Long#compare/comp(other)
+
+Compares this Long's value with the specified's.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long &#124; number &#124; string* | Other value 
+| **@returns**    | *number*        | 0 if they are the same, 1 if the this is greater and -1 if the given one is greater 
+
+#### Long#divide/div(divisor)
+
+Returns this Long divided by the specified.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| divisor         | *!Long &#124; number &#124; string* | Divisor 
+| **@returns**    | *!Long*         | Quotient 
+
+#### Long#equals/eq(other)
+
+Tests if this Long's value equals the specified's.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long &#124; number &#124; string* | Other value 
+| **@returns**    | *boolean*       | 
+
+#### Long#getHighBits()
+
+Gets the high 32 bits as a signed integer.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *number*        | Signed high bits 
+
+#### Long#getHighBitsUnsigned()
+
+Gets the high 32 bits as an unsigned integer.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *number*        | Unsigned high bits 
+
+#### Long#getLowBits()
+
+Gets the low 32 bits as a signed integer.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *number*        | Signed low bits 
+
+#### Long#getLowBitsUnsigned()
+
+Gets the low 32 bits as an unsigned integer.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *number*        | Unsigned low bits 
+
+#### Long#getNumBitsAbs()
+
+Gets the number of bits needed to represent the absolute value of this Long.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *number*        | 
+
+#### Long#greaterThan/gt(other)
+
+Tests if this Long's value is greater than the specified's.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long &#124; number &#124; string* | Other value 
+| **@returns**    | *boolean*       | 
+
+#### Long#greaterThanOrEqual/gte(other)
+
+Tests if this Long's value is greater than or equal the specified's.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long &#124; number &#124; string* | Other value 
+| **@returns**    | *boolean*       | 
+
+#### Long#isEven()
+
+Tests if this Long's value is even.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *boolean*       | 
+
+#### Long#isNegative()
+
+Tests if this Long's value is negative.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *boolean*       | 
+
+#### Long#isOdd()
+
+Tests if this Long's value is odd.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *boolean*       | 
+
+#### Long#isPositive()
+
+Tests if this Long's value is positive.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *boolean*       | 
+
+#### Long#isZero()
+
+Tests if this Long's value equals zero.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *boolean*       | 
+
+#### Long#lessThan/lt(other)
+
+Tests if this Long's value is less than the specified's.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long &#124; number &#124; string* | Other value 
+| **@returns**    | *boolean*       | 
+
+#### Long#lessThanOrEqual/lte(other)
+
+Tests if this Long's value is less than or equal the specified's.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long &#124; number &#124; string* | Other value 
+| **@returns**    | *boolean*       | 
+
+#### Long#modulo/mod(divisor)
+
+Returns this Long modulo the specified.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| divisor         | *!Long &#124; number &#124; string* | Divisor 
+| **@returns**    | *!Long*         | Remainder 
+
+#### Long#multiply/mul(multiplier)
+
+Returns the product of this and the specified Long.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| multiplier      | *!Long &#124; number &#124; string* | Multiplier 
+| **@returns**    | *!Long*         | Product 
+
+#### Long#negate/neg()
+
+Negates this Long's value.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *!Long*         | Negated Long 
+
+#### Long#not()
+
+Returns the bitwise NOT of this Long.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *!Long*         | 
+
+#### Long#notEquals/neq(other)
+
+Tests if this Long's value differs from the specified's.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long &#124; number &#124; string* | Other value 
+| **@returns**    | *boolean*       | 
+
+#### Long#or(other)
+
+Returns the bitwise OR of this Long and the specified.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long &#124; number &#124; string* | Other Long 
+| **@returns**    | *!Long*         | 
+
+#### Long#shiftLeft/shl(numBits)
+
+Returns this Long with bits shifted to the left by the given amount.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| numBits         | *number &#124; !Long* | Number of bits 
+| **@returns**    | *!Long*         | Shifted Long 
+
+#### Long#shiftRight/shr(numBits)
+
+Returns this Long with bits arithmetically shifted to the right by the given amount.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| numBits         | *number &#124; !Long* | Number of bits 
+| **@returns**    | *!Long*         | Shifted Long 
+
+#### Long#shiftRightUnsigned/shru(numBits)
+
+Returns this Long with bits logically shifted to the right by the given amount.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| numBits         | *number &#124; !Long* | Number of bits 
+| **@returns**    | *!Long*         | Shifted Long 
+
+#### Long#subtract/sub(subtrahend)
+
+Returns the difference of this and the specified Long.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| subtrahend      | *!Long &#124; number &#124; string* | Subtrahend 
+| **@returns**    | *!Long*         | Difference 
+
+#### Long#toInt()
+
+Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *number*        | 
+
+#### Long#toNumber()
+
+Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *number*        | 
+
+#### Long#toSigned()
+
+Converts this Long to signed.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *!Long*         | Signed long 
+
+#### Long#toString(radix=)
+
+Converts the Long to a string written in the specified radix.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| radix           | *number*        | Radix (2-36), defaults to 10 
+| **@returns**    | *string*        | 
+| **@throws**     | *RangeError*    | If `radix` is out of range 
+
+#### Long#toUnsigned()
+
+Converts this Long to unsigned.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *!Long*         | Unsigned long 
+
+#### Long#xor(other)
+
+Returns the bitwise XOR of this Long and the given one.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long &#124; number &#124; string* | Other Long 
+| **@returns**    | *!Long*         | 
+
+Downloads
+---------
+* [Distributions](https://github.com/dcodeIO/long.js/tree/master/dist)
+* [ZIP-Archive](https://github.com/dcodeIO/long.js/archive/master.zip)
+* [Tarball](https://github.com/dcodeIO/long.js/tarball/master)
+
+License
+-------
+Apache License, Version 2.0 - http://www.apache.org/licenses/LICENSE-2.0.html

node_modules/bytebuffer/node_modules/long/bower.json

@@ -0,0 +1,9 @@
+{
+    "name": "long",
+    "version": "3.2.0",
+    "author": "Daniel Wirtz <dcode@dcode.io>",
+    "description": "A Long class for representing a 64 bit two's-complement integer value.",
+    "main": "dist/long.js",
+    "keywords": ["math"],
+    "license": "Apache-2.0"
+}

node_modules/bytebuffer/node_modules/long/dist/README.md

@@ -0,0 +1,16 @@
+Distributions
+=============
+
+* **[long.js](https://raw.githubusercontent.com/dcodeIO/Long.js/master/dist/long.js)**  
+  contains the commented source.
+  
+* **[long.min.js](https://raw.githubusercontent.com/dcodeIO/Long.js/master/dist/long.min.js)**  
+  has been compiled with Closure Compiler.
+  
+* **[long.min.js.gz](https://raw.githubusercontent.com/dcodeIO/Long.js/master/dist/long.min.js.gz)**  
+  has also been gzipped using `-9`.
+  
+* **[long.min.map](https://raw.githubusercontent.com/dcodeIO/Long.js/master/dist/long.min.map)**  
+  is the source map generated by Closure Compiler.
+
+Also available as `long` on [npm](https://www.npmjs.org/package/long) and [bower](http://bower.io/search/?q=long).

node_modules/bytebuffer/node_modules/long/dist/long.min.js

@@ -0,0 +1,20 @@
+/*
+ long.js (c) 2013 Daniel Wirtz <dcode@dcode.io>
+ Released under the Apache License, Version 2.0
+ see: https://github.com/dcodeIO/long.js for details
+*/
+(function(d,g){"function"===typeof define&&define.amd?define([],g):"function"===typeof require&&"object"===typeof module&&module&&module.exports?module.exports=g():(d.dcodeIO=d.dcodeIO||{}).Long=g()})(this,function(){function d(a,b,c){this.low=a|0;this.high=b|0;this.unsigned=!!c}function g(a){return!0===(a&&a.__isLong__)}function m(a,b){var c,t;if(b){a>>>=0;if(t=0<=a&&256>a)if(c=z[a])return c;c=e(a,0>(a|0)?-1:0,!0);t&&(z[a]=c)}else{a|=0;if(t=-128<=a&&128>a)if(c=A[a])return c;c=e(a,0>a?-1:0,!1);t&&
+(A[a]=c)}return c}function n(a,b){if(isNaN(a)||!isFinite(a))return b?p:k;if(b){if(0>a)return p;if(a>=B)return C}else{if(a<=-D)return l;if(a+1>=D)return E}return 0>a?n(-a,b).neg():e(a%4294967296|0,a/4294967296|0,b)}function e(a,b,c){return new d(a,b,c)}function x(a,b,c){if(0===a.length)throw Error("empty string");if("NaN"===a||"Infinity"===a||"+Infinity"===a||"-Infinity"===a)return k;"number"===typeof b?(c=b,b=!1):b=!!b;c=c||10;if(2>c||36<c)throw RangeError("radix");var t;if(0<(t=a.indexOf("-")))throw Error("interior hyphen");
+if(0===t)return x(a.substring(1),b,c).neg();t=n(v(c,8));for(var e=k,f=0;f<a.length;f+=8){var d=Math.min(8,a.length-f),g=parseInt(a.substring(f,f+d),c);8>d?(d=n(v(c,d)),e=e.mul(d).add(n(g))):(e=e.mul(t),e=e.add(n(g)))}e.unsigned=b;return e}function q(a){return a instanceof d?a:"number"===typeof a?n(a):"string"===typeof a?x(a):e(a.low,a.high,a.unsigned)}Object.defineProperty(d.prototype,"__isLong__",{value:!0,enumerable:!1,configurable:!1});d.isLong=g;var A={},z={};d.fromInt=m;d.fromNumber=n;d.fromBits=
+e;var v=Math.pow;d.fromString=x;d.fromValue=q;var B=4294967296*4294967296,D=B/2,F=m(16777216),k=m(0);d.ZERO=k;var p=m(0,!0);d.UZERO=p;var r=m(1);d.ONE=r;var G=m(1,!0);d.UONE=G;var y=m(-1);d.NEG_ONE=y;var E=e(-1,2147483647,!1);d.MAX_VALUE=E;var C=e(-1,-1,!0);d.MAX_UNSIGNED_VALUE=C;var l=e(0,-2147483648,!1);d.MIN_VALUE=l;var b=d.prototype;b.toInt=function(){return this.unsigned?this.low>>>0:this.low};b.toNumber=function(){return this.unsigned?4294967296*(this.high>>>0)+(this.low>>>0):4294967296*this.high+
+(this.low>>>0)};b.toString=function(a){a=a||10;if(2>a||36<a)throw RangeError("radix");if(this.isZero())return"0";if(this.isNegative()){if(this.eq(l)){var b=n(a),c=this.div(b),b=c.mul(b).sub(this);return c.toString(a)+b.toInt().toString(a)}return"-"+this.neg().toString(a)}for(var c=n(v(a,6),this.unsigned),b=this,e="";;){var d=b.div(c),f=(b.sub(d.mul(c)).toInt()>>>0).toString(a),b=d;if(b.isZero())return f+e;for(;6>f.length;)f="0"+f;e=""+f+e}};b.getHighBits=function(){return this.high};b.getHighBitsUnsigned=
+function(){return this.high>>>0};b.getLowBits=function(){return this.low};b.getLowBitsUnsigned=function(){return this.low>>>0};b.getNumBitsAbs=function(){if(this.isNegative())return this.eq(l)?64:this.neg().getNumBitsAbs();for(var a=0!=this.high?this.high:this.low,b=31;0<b&&0==(a&1<<b);b--);return 0!=this.high?b+33:b+1};b.isZero=function(){return 0===this.high&&0===this.low};b.isNegative=function(){return!this.unsigned&&0>this.high};b.isPositive=function(){return this.unsigned||0<=this.high};b.isOdd=
+function(){return 1===(this.low&1)};b.isEven=function(){return 0===(this.low&1)};b.equals=function(a){g(a)||(a=q(a));return this.unsigned!==a.unsigned&&1===this.high>>>31&&1===a.high>>>31?!1:this.high===a.high&&this.low===a.low};b.eq=b.equals;b.notEquals=function(a){return!this.eq(a)};b.neq=b.notEquals;b.lessThan=function(a){return 0>this.comp(a)};b.lt=b.lessThan;b.lessThanOrEqual=function(a){return 0>=this.comp(a)};b.lte=b.lessThanOrEqual;b.greaterThan=function(a){return 0<this.comp(a)};b.gt=b.greaterThan;
+b.greaterThanOrEqual=function(a){return 0<=this.comp(a)};b.gte=b.greaterThanOrEqual;b.compare=function(a){g(a)||(a=q(a));if(this.eq(a))return 0;var b=this.isNegative(),c=a.isNegative();return b&&!c?-1:!b&&c?1:this.unsigned?a.high>>>0>this.high>>>0||a.high===this.high&&a.low>>>0>this.low>>>0?-1:1:this.sub(a).isNegative()?-1:1};b.comp=b.compare;b.negate=function(){return!this.unsigned&&this.eq(l)?l:this.not().add(r)};b.neg=b.negate;b.add=function(a){g(a)||(a=q(a));var b=this.high>>>16,c=this.high&65535,
+d=this.low>>>16,l=a.high>>>16,f=a.high&65535,n=a.low>>>16,k;k=0+((this.low&65535)+(a.low&65535));a=0+(k>>>16);a+=d+n;d=0+(a>>>16);d+=c+f;c=0+(d>>>16);c=c+(b+l)&65535;return e((a&65535)<<16|k&65535,c<<16|d&65535,this.unsigned)};b.subtract=function(a){g(a)||(a=q(a));return this.add(a.neg())};b.sub=b.subtract;b.multiply=function(a){if(this.isZero())return k;g(a)||(a=q(a));if(a.isZero())return k;if(this.eq(l))return a.isOdd()?l:k;if(a.eq(l))return this.isOdd()?l:k;if(this.isNegative())return a.isNegative()?
+this.neg().mul(a.neg()):this.neg().mul(a).neg();if(a.isNegative())return this.mul(a.neg()).neg();if(this.lt(F)&&a.lt(F))return n(this.toNumber()*a.toNumber(),this.unsigned);var b=this.high>>>16,c=this.high&65535,d=this.low>>>16,w=this.low&65535,f=a.high>>>16,m=a.high&65535,p=a.low>>>16;a=a.low&65535;var u,h,s,r;r=0+w*a;s=0+(r>>>16);s+=d*a;h=0+(s>>>16);s=(s&65535)+w*p;h+=s>>>16;s&=65535;h+=c*a;u=0+(h>>>16);h=(h&65535)+d*p;u+=h>>>16;h&=65535;h+=w*m;u+=h>>>16;h&=65535;u=u+(b*a+c*p+d*m+w*f)&65535;return e(s<<
+16|r&65535,u<<16|h,this.unsigned)};b.mul=b.multiply;b.divide=function(a){g(a)||(a=q(a));if(a.isZero())throw Error("division by zero");if(this.isZero())return this.unsigned?p:k;var b,c,d;if(this.unsigned){a.unsigned||(a=a.toUnsigned());if(a.gt(this))return p;if(a.gt(this.shru(1)))return G;d=p}else{if(this.eq(l)){if(a.eq(r)||a.eq(y))return l;if(a.eq(l))return r;b=this.shr(1).div(a).shl(1);if(b.eq(k))return a.isNegative()?r:y;c=this.sub(a.mul(b));return d=b.add(c.div(a))}if(a.eq(l))return this.unsigned?
+p:k;if(this.isNegative())return a.isNegative()?this.neg().div(a.neg()):this.neg().div(a).neg();if(a.isNegative())return this.div(a.neg()).neg();d=k}for(c=this;c.gte(a);){b=Math.max(1,Math.floor(c.toNumber()/a.toNumber()));for(var e=Math.ceil(Math.log(b)/Math.LN2),e=48>=e?1:v(2,e-48),f=n(b),m=f.mul(a);m.isNegative()||m.gt(c);)b-=e,f=n(b,this.unsigned),m=f.mul(a);f.isZero()&&(f=r);d=d.add(f);c=c.sub(m)}return d};b.div=b.divide;b.modulo=function(a){g(a)||(a=q(a));return this.sub(this.div(a).mul(a))};
+b.mod=b.modulo;b.not=function(){return e(~this.low,~this.high,this.unsigned)};b.and=function(a){g(a)||(a=q(a));return e(this.low&a.low,this.high&a.high,this.unsigned)};b.or=function(a){g(a)||(a=q(a));return e(this.low|a.low,this.high|a.high,this.unsigned)};b.xor=function(a){g(a)||(a=q(a));return e(this.low^a.low,this.high^a.high,this.unsigned)};b.shiftLeft=function(a){g(a)&&(a=a.toInt());return 0===(a&=63)?this:32>a?e(this.low<<a,this.high<<a|this.low>>>32-a,this.unsigned):e(0,this.low<<a-32,this.unsigned)};
+b.shl=b.shiftLeft;b.shiftRight=function(a){g(a)&&(a=a.toInt());return 0===(a&=63)?this:32>a?e(this.low>>>a|this.high<<32-a,this.high>>a,this.unsigned):e(this.high>>a-32,0<=this.high?0:-1,this.unsigned)};b.shr=b.shiftRight;b.shiftRightUnsigned=function(a){g(a)&&(a=a.toInt());a&=63;if(0===a)return this;var b=this.high;return 32>a?e(this.low>>>a|b<<32-a,b>>>a,this.unsigned):32===a?e(b,0,this.unsigned):e(b>>>a-32,0,this.unsigned)};b.shru=b.shiftRightUnsigned;b.toSigned=function(){return this.unsigned?
+e(this.low,this.high,!1):this};b.toUnsigned=function(){return this.unsigned?this:e(this.low,this.high,!0)};b.toBytes=function(a){return a?this.toBytesLE():this.toBytesBE()};b.toBytesLE=function(){var a=this.high,b=this.low;return[b&255,b>>>8&255,b>>>16&255,b>>>24&255,a&255,a>>>8&255,a>>>16&255,a>>>24&255]};b.toBytesBE=function(){var a=this.high,b=this.low;return[a>>>24&255,a>>>16&255,a>>>8&255,a&255,b>>>24&255,b>>>16&255,b>>>8&255,b&255]};return d});

node_modules/bytebuffer/node_modules/long/doco/INDEX.md

@@ -0,0 +1,6 @@
+### Class [Long](Long.md)
+
+A Long class for representing a 64 bit two's-complement integer value.
+
+---
+*Generated with [doco](https://github.com/dcodeIO/doco) v0.3.0*

node_modules/bytebuffer/node_modules/long/doco/Long.md

@@ -0,0 +1,473 @@
+## Class Long
+
+A Long class for representing a 64 bit two's-complement integer value.
+
+---
+
+#### new Long(low, high=, unsigned=)
+
+Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.
+See the from* functions below for more convenient ways of constructing Longs.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| low             | *number*        | The low (signed) 32 bits of the long 
+| high            | *number*        | The high (signed) 32 bits of the long 
+| unsigned        | *boolean*       | Whether unsigned or not, defaults to `false` for signed 
+
+---
+
+#### Long.MAX_UNSIGNED_VALUE
+
+Maximum unsigned value.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *!Long*         |
+
+#### Long.MAX_VALUE
+
+Maximum signed value.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *!Long*         |
+
+#### Long.MIN_VALUE
+
+Minimum signed value.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *!Long*         |
+
+#### Long.NEG_ONE
+
+Signed negative one.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *!Long*         |
+
+#### Long.ONE
+
+Signed one.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *!Long*         |
+
+#### Long.UONE
+
+Unsigned one.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *!Long*         |
+
+#### Long.UZERO
+
+Unsigned zero.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *!Long*         |
+
+#### Long.ZERO
+
+Signed zero.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *!Long*         |
+
+#### Long.fromBits(lowBits, highBits, unsigned=)
+
+Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is
+assumed to use 32 bits.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| lowBits         | *number*        | The low 32 bits 
+| highBits        | *number*        | The high 32 bits 
+| unsigned        | *boolean*       | Whether unsigned or not, defaults to `false` for signed 
+| **@returns**    | *!Long*         | The corresponding Long value 
+
+#### Long.fromInt(value, unsigned=)
+
+Returns a Long representing the given 32 bit integer value.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| value           | *number*        | The 32 bit integer in question 
+| unsigned        | *boolean*       | Whether unsigned or not, defaults to `false` for signed 
+| **@returns**    | *!Long*         | The corresponding Long value 
+
+#### Long.fromNumber(value, unsigned=)
+
+Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| value           | *number*        | The number in question 
+| unsigned        | *boolean*       | Whether unsigned or not, defaults to `false` for signed 
+| **@returns**    | *!Long*         | The corresponding Long value 
+
+#### Long.fromString(str, unsigned=, radix=)
+
+Returns a Long representation of the given string, written using the specified radix.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| str             | *string*        | The textual representation of the Long 
+| unsigned        | *boolean | number* | Whether unsigned or not, defaults to `false` for signed 
+| radix           | *number*        | The radix in which the text is written (2-36), defaults to 10 
+| **@returns**    | *!Long*         | The corresponding Long value 
+
+#### Long.isLong(obj)
+
+Tests if the specified object is a Long.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| obj             | ***             | Object 
+| **@returns**    | *boolean*       | 
+
+#### Long.fromValue(val)
+
+Converts the specified value to a Long.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| val             | *!Long | number | string | !{low: number, high: number, unsigned: boolean}* | Value 
+| **@returns**    | *!Long*         | 
+
+---
+
+#### Long#high
+
+The high 32 bits as a signed value.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *number*        |
+
+#### Long#low
+
+The low 32 bits as a signed value.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *number*        |
+
+#### Long#unsigned
+
+Whether unsigned or not.
+
+|                 |                 |
+|-----------------|-----------------|
+| **@type**       | *boolean*       |
+
+#### Long#add(addend)
+
+Returns the sum of this and the specified Long.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| addend          | *!Long | number | string* | Addend 
+| **@returns**    | *!Long*         | Sum 
+
+#### Long#and(other)
+
+Returns the bitwise AND of this Long and the specified.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long | number | string* | Other Long 
+| **@returns**    | *!Long*         | 
+
+#### Long#compare(other)
+
+Compares this Long's value with the specified's.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long | number | string* | Other value 
+| **@returns**    | *number*        | 0 if they are the same, 1 if the this is greater and -1 if the given one is greater 
+
+#### Long#div(divisor)
+
+Returns this Long divided by the specified.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| divisor         | *!Long | number | string* | Divisor 
+| **@returns**    | *!Long*         | Quotient 
+
+#### Long#equals(other)
+
+Tests if this Long's value equals the specified's.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long | number | string* | Other value 
+| **@returns**    | *boolean*       | 
+
+#### Long#getHighBits()
+
+Gets the high 32 bits as a signed integer.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *number*        | Signed high bits 
+
+#### Long#getHighBitsUnsigned()
+
+Gets the high 32 bits as an unsigned integer.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *number*        | Unsigned high bits 
+
+#### Long#getLowBits()
+
+Gets the low 32 bits as a signed integer.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *number*        | Signed low bits 
+
+#### Long#getLowBitsUnsigned()
+
+Gets the low 32 bits as an unsigned integer.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *number*        | Unsigned low bits 
+
+#### Long#getNumBitsAbs()
+
+Gets the number of bits needed to represent the absolute value of this Long.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *number*        | 
+
+#### Long#greaterThan(other)
+
+Tests if this Long's value is greater than the specified's.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long | number | string* | Other value 
+| **@returns**    | *boolean*       | 
+
+#### Long#greaterThanOrEqual(other)
+
+Tests if this Long's value is greater than or equal the specified's.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long | number | string* | Other value 
+| **@returns**    | *boolean*       | 
+
+#### Long#isEven()
+
+Tests if this Long's value is even.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *boolean*       | 
+
+#### Long#isNegative()
+
+Tests if this Long's value is negative.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *boolean*       | 
+
+#### Long#isOdd()
+
+Tests if this Long's value is odd.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *boolean*       | 
+
+#### Long#isPositive()
+
+Tests if this Long's value is positive.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *boolean*       | 
+
+#### Long#isZero()
+
+Tests if this Long's value equals zero.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *boolean*       | 
+
+#### Long#lessThan(other)
+
+Tests if this Long's value is less than the specified's.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long | number | string* | Other value 
+| **@returns**    | *boolean*       | 
+
+#### Long#lessThanOrEqual(other)
+
+Tests if this Long's value is less than or equal the specified's.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long | number | string* | Other value 
+| **@returns**    | *boolean*       | 
+
+#### Long#modulo(divisor)
+
+Returns this Long modulo the specified.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| divisor         | *!Long | number | string* | Divisor 
+| **@returns**    | *!Long*         | Remainder 
+
+#### Long#multiply(multiplier)
+
+Returns the product of this and the specified Long.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| multiplier      | *!Long | number | string* | Multiplier 
+| **@returns**    | *!Long*         | Product 
+
+#### Long#negate()
+
+Negates this Long's value.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *!Long*         | Negated Long 
+
+#### Long#not()
+
+Returns the bitwise NOT of this Long.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *!Long*         | 
+
+#### Long#notEquals(other)
+
+Tests if this Long's value differs from the specified's.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long | number | string* | Other value 
+| **@returns**    | *boolean*       | 
+
+#### Long#or(other)
+
+Returns the bitwise OR of this Long and the specified.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long | number | string* | Other Long 
+| **@returns**    | *!Long*         | 
+
+#### Long#shiftLeft(numBits)
+
+Returns this Long with bits shifted to the left by the given amount.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| numBits         | *number | !Long* | Number of bits 
+| **@returns**    | *!Long*         | Shifted Long 
+
+#### Long#shiftRight(numBits)
+
+Returns this Long with bits arithmetically shifted to the right by the given amount.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| numBits         | *number | !Long* | Number of bits 
+| **@returns**    | *!Long*         | Shifted Long 
+
+#### Long#shiftRightUnsigned(numBits)
+
+Returns this Long with bits logically shifted to the right by the given amount.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| numBits         | *number | !Long* | Number of bits 
+| **@returns**    | *!Long*         | Shifted Long 
+
+#### Long#subtract(subtrahend)
+
+Returns the difference of this and the specified Long.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| subtrahend      | *!Long | number | string* | Subtrahend 
+| **@returns**    | *!Long*         | Difference 
+
+#### Long#toInt()
+
+Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *number*        | 
+
+#### Long#toNumber()
+
+Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *number*        | 
+
+#### Long#toSigned()
+
+Converts this Long to signed.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *!Long*         | Signed long 
+
+#### Long#toString(radix=)
+
+Converts the Long to a string written in the specified radix.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| radix           | *number*        | Radix (2-36), defaults to 10 
+| **@returns**    | *string*        | 
+| **@throws**     | *RangeError*    | If `radix` is out of range 
+
+#### Long#toUnsigned()
+
+Converts this Long to unsigned.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| **@returns**    | *!Long*         | Unsigned long 
+
+#### Long#xor(other)
+
+Returns the bitwise XOR of this Long and the given one.
+
+| Parameter       | Type            | Description
+|-----------------|-----------------|---------------
+| other           | *!Long | number | string* | Other Long 
+| **@returns**    | *!Long*         | 
+
+
+---
+*Generated with [doco](https://github.com/dcodeIO/doco) v0.3.0*

node_modules/bytebuffer/node_modules/long/externs/long.js

@@ -0,0 +1,416 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Externs for Long.js.
+ * @see https://github.com/dcodeIO/Long.js
+ * @externs
+ */
+
+/**
+ BEGIN_NODE_INCLUDE
+ var Long = require('long');
+ END_NODE_INCLUDE
+ */
+
+/**
+ * @param {number|!{low: number, high: number, unsigned: boolean}} low
+ * @param {number=} high
+ * @param {boolean=} unsigned
+ * @constructor
+ */
+var Long = function(low, high, unsigned) {};
+
+/**
+ * @param {*} obj
+ * @returns {boolean}
+ */
+Long.isLong = function(obj) {};
+
+/**
+ * @param {number} value
+ * @param {boolean=} unsigned
+ * @return {!Long}
+ */
+Long.fromInt = function(value, unsigned) {};
+
+/**
+ * @param {number} value
+ * @param {boolean=} unsigned
+ * @return {!Long}
+ */
+Long.fromNumber = function(value, unsigned) {};
+
+/**
+ * @param {number} lowBits
+ * @param {number} highBits
+ * @param {boolean=} unsigned
+ * @return {!Long}
+ */
+Long.fromBits = function(lowBits, highBits, unsigned) {};
+
+/**
+ * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val
+ * @returns {!Long}
+ */
+Long.fromValue = function(val) {};
+
+/**
+ * @param {string} str
+ * @param {(boolean|number)=} unsigned
+ * @param {number=} radix
+ * @return {!Long}
+ */
+Long.fromString = function(str, unsigned, radix) {};
+
+/**
+ * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val
+ * @return {!Long}
+ */
+Long.valueOf = function(val) {};
+
+/**
+ * @type {!Long}
+ */
+Long.ZERO;
+
+/**
+ * @type {!Long}
+ */
+Long.UZERO;
+
+/**
+ * @type {!Long}
+ */
+Long.ONE;
+
+/**
+ * @type {!Long}
+ */
+Long.UONE;
+
+/**
+ * @type {!Long}
+ */
+Long.NEG_ONE;
+
+/**
+ * @type {!Long}
+ */
+Long.MAX_VALUE;
+
+/**
+ * @type {!Long}
+ */
+Long.MIN_VALUE;
+
+/**
+ * @type {!Long}
+ */
+Long.MAX_UNSIGNED_VALUE;
+
+/**
+ * @type {number}
+ */
+Long.prototype.low;
+
+/**
+ * @type {number}
+ */
+Long.prototype.high;
+
+/**
+ * @type {boolean}
+ */
+Long.prototype.unsigned;
+
+/**
+ * @return {number}
+ */
+Long.prototype.toInt = function() {};
+
+/**
+ * @return {number}
+ */
+Long.prototype.toNumber = function() {};
+
+/**
+ * @param {number=} radix
+ * @return {string}
+ */
+Long.prototype.toString = function(radix) {};
+
+/**
+ * @return {number}
+ */
+Long.prototype.getHighBits = function() {};
+
+/**
+ * @return {number}
+ */
+Long.prototype.getHighBitsUnsigned = function() {};
+
+/**
+ * @return {number}
+ */
+Long.prototype.getLowBits = function() {};
+
+/**
+ * @return {number}
+ */
+Long.prototype.getLowBitsUnsigned = function() {};
+
+/**
+ * @return {number}
+ */
+Long.prototype.getNumBitsAbs = function() {};
+
+/**
+ * @return {boolean}
+ */
+Long.prototype.isZero = function() {};
+
+/**
+ * @return {boolean}
+ */
+Long.prototype.isNegative = function() {};
+
+/**
+ * @return {boolean}
+ */
+Long.prototype.isOdd = function() {};
+
+/**
+ * @return {boolean}
+ */
+Long.prototype.isEven = function() {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {boolean}
+ */
+Long.prototype.equals = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {boolean}
+ */
+Long.prototype.eq = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {boolean}
+ */
+Long.prototype.notEquals = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {boolean}
+ */
+Long.prototype.neq = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {boolean}
+ */
+Long.prototype.lessThan = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {boolean}
+ */
+Long.prototype.lt = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {boolean}
+ */
+Long.prototype.lessThanOrEqual = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {boolean}
+ */
+Long.prototype.lte = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {boolean}
+ */
+Long.prototype.greaterThan = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {boolean}
+ */
+Long.prototype.gt = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {boolean}
+ */
+Long.prototype.greaterThanOrEqual = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {boolean}
+ */
+Long.prototype.gte = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {number}
+ */
+Long.prototype.compare = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {number}
+ */
+Long.prototype.comp = function(other) {};
+
+/**
+ * @return {!Long}
+ */
+Long.prototype.negate = function() {};
+
+/**
+ * @return {!Long}
+ */
+Long.prototype.neg = function() {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {!Long}
+ */
+Long.prototype.add = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {!Long}
+ */
+Long.prototype.subtract = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {!Long}
+ */
+Long.prototype.sub = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {!Long}
+ */
+Long.prototype.multiply = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {!Long}
+ */
+Long.prototype.mul = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {!Long}
+ */
+Long.prototype.divide = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {!Long}
+ */
+Long.prototype.div = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {!Long}
+ */
+Long.prototype.modulo = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {!Long}
+ */
+Long.prototype.mod = function(other) {};
+
+/**
+ * @return {!Long}
+ */
+Long.prototype.not = function() {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {!Long}
+ */
+Long.prototype.and = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {!Long}
+ */
+Long.prototype.or = function(other) {};
+
+/**
+ * @param {!Long|number|string} other
+ * @return {!Long}
+ */
+Long.prototype.xor = function(other) {};
+
+/**
+ * @param {number|!Long} numBits
+ * @return {!Long}
+ */
+Long.prototype.shiftLeft = function(numBits) {};
+
+/**
+ * @param {number|!Long} numBits
+ * @return {!Long}
+ */
+Long.prototype.shl = function(numBits) {};
+
+/**
+ * @param {number|!Long} numBits
+ * @return {!Long}
+ */
+Long.prototype.shiftRight = function(numBits) {};
+
+/**
+ * @param {number|!Long} numBits
+ * @return {!Long}
+ */
+Long.prototype.shr = function(numBits) {};
+
+/**
+ * @param {number|!Long} numBits
+ * @return {!Long}
+ */
+Long.prototype.shiftRightUnsigned = function(numBits) {};
+
+/**
+ * @param {number|!Long} numBits
+ * @return {!Long}
+ */
+Long.prototype.shru = function(numBits) {};
+
+/**
+ * @return {!Long}
+ */
+Long.prototype.toSigned = function() {};
+
+/**
+ * @return {!Long}
+ */
+Long.prototype.toUnsigned = function() {};

node_modules/bytebuffer/node_modules/long/index.js

@@ -0,0 +1 @@
+module.exports = require("./dist/long.js");

node_modules/bytebuffer/node_modules/long/jsdoc.json

@@ -0,0 +1,13 @@
+{
+    "tags": {
+        "allowUnknownTags": true
+    },
+    "source": {
+        "include": ["dist/long.js"]
+    },
+    "opts": {
+        "template": "templates/esoccer",
+        "destination": "docs"
+    },
+    "plugins": []
+}

node_modules/bytebuffer/node_modules/long/package.json

@@ -0,0 +1,66 @@
+{
+  "_args": [
+    [
+      "long@3.2.0",
+      "C:\\Users\\matia\\Musix"
+    ]
+  ],
+  "_from": "long@3.2.0",
+  "_id": "long@3.2.0",
+  "_inBundle": false,
+  "_integrity": "sha1-2CG3E4yhy1gcFymQ7xTbIAtcR0s=",
+  "_location": "/bytebuffer/long",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "long@3.2.0",
+    "name": "long",
+    "escapedName": "long",
+    "rawSpec": "3.2.0",
+    "saveSpec": null,
+    "fetchSpec": "3.2.0"
+  },
+  "_requiredBy": [
+    "/bytebuffer"
+  ],
+  "_resolved": "https://registry.npmjs.org/long/-/long-3.2.0.tgz",
+  "_spec": "3.2.0",
+  "_where": "C:\\Users\\matia\\Musix",
+  "author": {
+    "name": "Daniel Wirtz",
+    "email": "dcode@dcode.io"
+  },
+  "bugs": {
+    "url": "https://github.com/dcodeIO/long.js/issues"
+  },
+  "dependencies": {},
+  "description": "A Long class for representing a 64-bit two's-complement integer value.",
+  "devDependencies": {
+    "closurecompiler": "^1.6",
+    "metascript": "~0",
+    "testjs": "latest"
+  },
+  "engines": {
+    "node": ">=0.6"
+  },
+  "homepage": "https://github.com/dcodeIO/long.js#readme",
+  "keywords": [
+    "math"
+  ],
+  "license": "Apache-2.0",
+  "main": "dist/long.js",
+  "name": "long",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dcodeIO/long.js.git"
+  },
+  "scripts": {
+    "build": "node scripts/build.js",
+    "compile": "ccjs dist/long.js --compilation_level=SIMPLE_OPTIMIZATIONS --create_source_map=dist/long.min.map > dist/long.min.js",
+    "compress": "gzip -c -9 dist/long.min.js > dist/long.min.js.gz",
+    "make": "npm run-script build && npm run-script compile && npm run-script compress && npm test",
+    "test": "node node_modules/testjs/bin/testjs tests/suite.js"
+  },
+  "version": "3.2.0"
+}

node_modules/bytebuffer/node_modules/long/scripts/build.js

@@ -0,0 +1,28 @@
+var MetaScript = require("metascript"),
+    path = require("path"),
+    fs = require("fs");
+
+var rootDir = path.join(__dirname, ".."),
+    srcDir = path.join(__dirname, "..", "src"),
+    distDir = path.join(__dirname, "..", "dist"),
+    pkg = require(path.join(rootDir, "package.json")),
+    filename;
+
+var scope = {};
+
+// Build
+console.log("Building long.js with scope", JSON.stringify(scope, null, 2));
+fs.writeFileSync(
+    path.join(distDir, "long.js"),
+    MetaScript.transform(fs.readFileSync(filename = path.join(srcDir, "wrap.js")), filename, scope, srcDir)
+);
+
+// Update bower.json
+scope = { VERSION: pkg.version };
+console.log("Updating bower.json with scope", JSON.stringify(scope, null, 2));
+fs.writeFileSync(
+    path.join(rootDir, "bower.json"),
+    MetaScript.transform(fs.readFileSync(filename = path.join(srcDir, "bower.json")), filename, scope, srcDir)
+);
+
+console.log("Done");

node_modules/bytebuffer/node_modules/long/src/bower.json

@@ -0,0 +1,9 @@
+{
+    "name": "long",
+    "version": "/*?= VERSION */",
+    "author": "Daniel Wirtz <dcode@dcode.io>",
+    "description": "A Long class for representing a 64 bit two's-complement integer value.",
+    "main": "dist/long.js",
+    "keywords": ["math"],
+    "license": "Apache-2.0"
+}

node_modules/bytebuffer/node_modules/long/src/wrap.js

@@ -0,0 +1,38 @@
+/*
+ Copyright 2013 Daniel Wirtz <dcode@dcode.io>
+ Copyright 2009 The Closure Library Authors. All Rights Reserved.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS-IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+/**
+ * @license long.js (c) 2013 Daniel Wirtz <dcode@dcode.io>
+ * Released under the Apache License, Version 2.0
+ * see: https://github.com/dcodeIO/long.js for details
+ */
+(function(global, factory) {
+
+    /* AMD */ if (typeof define === 'function' && define["amd"])
+        define([], factory);
+    /* CommonJS */ else if (typeof require === 'function' && typeof module === "object" && module && module["exports"])
+        module["exports"] = factory();
+    /* Global */ else
+        (global["dcodeIO"] = global["dcodeIO"] || {})["Long"] = factory();
+
+})(this, function() {
+    "use strict";
+
+    //? include("long.js");
+
+    return Long;
+});

node_modules/bytebuffer/node_modules/long/tests/goog.math.long.js

@@ -0,0 +1,807 @@
+// Copyright 2009 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview Defines a Long class for representing a 64-bit two's-complement
+ * integer value, which faithfully simulates the behavior of a Java "long". This
+ * implementation is derived from LongLib in GWT.
+ *
+ */
+
+// goog.provide('goog.math.Long');
+var goog = {}; goog.math = {};
+
+
+
+/**
+ * Constructs a 64-bit two's-complement integer, given its low and high 32-bit
+ * values as *signed* integers.  See the from* functions below for more
+ * convenient ways of constructing Longs.
+ *
+ * The internal representation of a long is the two given signed, 32-bit values.
+ * We use 32-bit pieces because these are the size of integers on which
+ * Javascript performs bit-operations.  For operations like addition and
+ * multiplication, we split each number into 16-bit pieces, which can easily be
+ * multiplied within Javascript's floating-point representation without overflow
+ * or change in sign.
+ *
+ * In the algorithms below, we frequently reduce the negative case to the
+ * positive case by negating the input(s) and then post-processing the result.
+ * Note that we must ALWAYS check specially whether those values are MIN_VALUE
+ * (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as
+ * a positive number, it overflows back into a negative).  Not handling this
+ * case would often result in infinite recursion.
+ *
+ * @param {number} low  The low (signed) 32 bits of the long.
+ * @param {number} high  The high (signed) 32 bits of the long.
+ * @constructor
+ * @final
+ */
+goog.math.Long = function(low, high) {
+    /**
+     * @type {number}
+     * @private
+     */
+    this.low_ = low | 0;  // force into 32 signed bits.
+
+    /**
+     * @type {number}
+     * @private
+     */
+    this.high_ = high | 0;  // force into 32 signed bits.
+};
+
+
+// NOTE: Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the
+// from* methods on which they depend.
+
+
+/**
+ * A cache of the Long representations of small integer values.
+ * @type {!Object}
+ * @private
+ */
+goog.math.Long.IntCache_ = {};
+
+
+/**
+ * Returns a Long representing the given (32-bit) integer value.
+ * @param {number} value The 32-bit integer in question.
+ * @return {!goog.math.Long} The corresponding Long value.
+ */
+goog.math.Long.fromInt = function(value) {
+    if (-128 <= value && value < 128) {
+        var cachedObj = goog.math.Long.IntCache_[value];
+        if (cachedObj) {
+            return cachedObj;
+        }
+    }
+
+    var obj = new goog.math.Long(value | 0, value < 0 ? -1 : 0);
+    if (-128 <= value && value < 128) {
+        goog.math.Long.IntCache_[value] = obj;
+    }
+    return obj;
+};
+
+
+/**
+ * Returns a Long representing the given value, provided that it is a finite
+ * number.  Otherwise, zero is returned.
+ * @param {number} value The number in question.
+ * @return {!goog.math.Long} The corresponding Long value.
+ */
+goog.math.Long.fromNumber = function(value) {
+    if (isNaN(value) || !isFinite(value)) {
+        return goog.math.Long.ZERO;
+    } else if (value <= -goog.math.Long.TWO_PWR_63_DBL_) {
+        return goog.math.Long.MIN_VALUE;
+    } else if (value + 1 >= goog.math.Long.TWO_PWR_63_DBL_) {
+        return goog.math.Long.MAX_VALUE;
+    } else if (value < 0) {
+        return goog.math.Long.fromNumber(-value).negate();
+    } else {
+        return new goog.math.Long(
+            (value % goog.math.Long.TWO_PWR_32_DBL_) | 0,
+            (value / goog.math.Long.TWO_PWR_32_DBL_) | 0);
+    }
+};
+
+
+/**
+ * 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.
+ * @param {number} lowBits The low 32-bits.
+ * @param {number} highBits The high 32-bits.
+ * @return {!goog.math.Long} The corresponding Long value.
+ */
+goog.math.Long.fromBits = function(lowBits, highBits) {
+    return new goog.math.Long(lowBits, highBits);
+};
+
+
+/**
+ * Returns a Long representation of the given string, written using the given
+ * radix.
+ * @param {string} str The textual representation of the Long.
+ * @param {number=} opt_radix The radix in which the text is written.
+ * @return {!goog.math.Long} The corresponding Long value.
+ */
+goog.math.Long.fromString = function(str, opt_radix) {
+    if (str.length == 0) {
+        throw Error('number format error: empty string');
+    }
+
+    var radix = opt_radix || 10;
+    if (radix < 2 || 36 < radix) {
+        throw Error('radix out of range: ' + radix);
+    }
+
+    if (str.charAt(0) == '-') {
+        return goog.math.Long.fromString(str.substring(1), radix).negate();
+    } else if (str.indexOf('-') >= 0) {
+        throw Error('number format error: interior "-" character: ' + str);
+    }
+
+    // Do several (8) digits each time through the loop, so as to
+    // minimize the calls to the very expensive emulated div.
+    var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 8));
+
+    var result = goog.math.Long.ZERO;
+    for (var i = 0; i < str.length; i += 8) {
+        var size = Math.min(8, str.length - i);
+        var value = parseInt(str.substring(i, i + size), radix);
+        if (size < 8) {
+            var power = goog.math.Long.fromNumber(Math.pow(radix, size));
+            result = result.multiply(power).add(goog.math.Long.fromNumber(value));
+        } else {
+            result = result.multiply(radixToPower);
+            result = result.add(goog.math.Long.fromNumber(value));
+        }
+    }
+    return result;
+};
+
+
+// NOTE: the compiler should inline these constant values below and then remove
+// these variables, so there should be no runtime penalty for these.
+
+
+/**
+ * Number used repeated below in calculations.  This must appear before the
+ * first call to any from* function below.
+ * @type {number}
+ * @private
+ */
+goog.math.Long.TWO_PWR_16_DBL_ = 1 << 16;
+
+
+/**
+ * @type {number}
+ * @private
+ */
+goog.math.Long.TWO_PWR_24_DBL_ = 1 << 24;
+
+
+/**
+ * @type {number}
+ * @private
+ */
+goog.math.Long.TWO_PWR_32_DBL_ =
+    goog.math.Long.TWO_PWR_16_DBL_ * goog.math.Long.TWO_PWR_16_DBL_;
+
+
+/**
+ * @type {number}
+ * @private
+ */
+goog.math.Long.TWO_PWR_31_DBL_ =
+    goog.math.Long.TWO_PWR_32_DBL_ / 2;
+
+
+/**
+ * @type {number}
+ * @private
+ */
+goog.math.Long.TWO_PWR_48_DBL_ =
+    goog.math.Long.TWO_PWR_32_DBL_ * goog.math.Long.TWO_PWR_16_DBL_;
+
+
+/**
+ * @type {number}
+ * @private
+ */
+goog.math.Long.TWO_PWR_64_DBL_ =
+    goog.math.Long.TWO_PWR_32_DBL_ * goog.math.Long.TWO_PWR_32_DBL_;
+
+
+/**
+ * @type {number}
+ * @private
+ */
+goog.math.Long.TWO_PWR_63_DBL_ =
+    goog.math.Long.TWO_PWR_64_DBL_ / 2;
+
+
+/** @type {!goog.math.Long} */
+goog.math.Long.ZERO = goog.math.Long.fromInt(0);
+
+
+/** @type {!goog.math.Long} */
+goog.math.Long.ONE = goog.math.Long.fromInt(1);
+
+
+/** @type {!goog.math.Long} */
+goog.math.Long.NEG_ONE = goog.math.Long.fromInt(-1);
+
+
+/** @type {!goog.math.Long} */
+goog.math.Long.MAX_VALUE =
+    goog.math.Long.fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0);
+
+
+/** @type {!goog.math.Long} */
+goog.math.Long.MIN_VALUE = goog.math.Long.fromBits(0, 0x80000000 | 0);
+
+
+/**
+ * @type {!goog.math.Long}
+ * @private
+ */
+goog.math.Long.TWO_PWR_24_ = goog.math.Long.fromInt(1 << 24);
+
+
+/** @return {number} The value, assuming it is a 32-bit integer. */
+goog.math.Long.prototype.toInt = function() {
+    return this.low_;
+};
+
+
+/** @return {number} The closest floating-point representation to this value. */
+goog.math.Long.prototype.toNumber = function() {
+    return this.high_ * goog.math.Long.TWO_PWR_32_DBL_ +
+        this.getLowBitsUnsigned();
+};
+
+
+/**
+ * @param {number=} opt_radix The radix in which the text should be written.
+ * @return {string} The textual representation of this value.
+ * @override
+ */
+goog.math.Long.prototype.toString = function(opt_radix) {
+    var radix = opt_radix || 10;
+    if (radix < 2 || 36 < radix) {
+        throw Error('radix out of range: ' + radix);
+    }
+
+    if (this.isZero()) {
+        return '0';
+    }
+
+    if (this.isNegative()) {
+        if (this.equals(goog.math.Long.MIN_VALUE)) {
+            // We need to change the Long value before it can be negated, so we remove
+            // the bottom-most digit in this base and then recurse to do the rest.
+            var radixLong = goog.math.Long.fromNumber(radix);
+            var div = this.div(radixLong);
+            var rem = div.multiply(radixLong).subtract(this);
+            return div.toString(radix) + rem.toInt().toString(radix);
+        } else {
+            return '-' + this.negate().toString(radix);
+        }
+    }
+
+    // Do several (6) digits each time through the loop, so as to
+    // minimize the calls to the very expensive emulated div.
+    var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 6));
+
+    var rem = this;
+    var result = '';
+    while (true) {
+        var remDiv = rem.div(radixToPower);
+        var intval = rem.subtract(remDiv.multiply(radixToPower)).toInt() >>> 0; // wraps around for base 36 (dcode)
+        console.log(intval);
+        var digits = intval.toString(radix);
+
+        rem = remDiv;
+        if (rem.isZero()) {
+            return digits + result;
+        } else {
+            while (digits.length < 6) {
+                digits = '0' + digits;
+            }
+            result = '' + digits + result;
+        }
+    }
+};
+
+
+/** @return {number} The high 32-bits as a signed value. */
+goog.math.Long.prototype.getHighBits = function() {
+    return this.high_;
+};
+
+
+/** @return {number} The low 32-bits as a signed value. */
+goog.math.Long.prototype.getLowBits = function() {
+    return this.low_;
+};
+
+
+/** @return {number} The low 32-bits as an unsigned value. */
+goog.math.Long.prototype.getLowBitsUnsigned = function() {
+    return (this.low_ >= 0) ?
+        this.low_ : goog.math.Long.TWO_PWR_32_DBL_ + this.low_;
+};
+
+
+/**
+ * @return {number} Returns the number of bits needed to represent the absolute
+ *     value of this Long.
+ */
+goog.math.Long.prototype.getNumBitsAbs = function() {
+    if (this.isNegative()) {
+        if (this.equals(goog.math.Long.MIN_VALUE)) {
+            return 64;
+        } else {
+            return this.negate().getNumBitsAbs();
+        }
+    } else {
+        var val = this.high_ != 0 ? this.high_ : this.low_;
+        for (var bit = 31; bit > 0; bit--) {
+            if ((val & (1 << bit)) != 0) {
+                break;
+            }
+        }
+        return this.high_ != 0 ? bit + 33 : bit + 1;
+    }
+};
+
+
+/** @return {boolean} Whether this value is zero. */
+goog.math.Long.prototype.isZero = function() {
+    return this.high_ == 0 && this.low_ == 0;
+};
+
+
+/** @return {boolean} Whether this value is negative. */
+goog.math.Long.prototype.isNegative = function() {
+    return this.high_ < 0;
+};
+
+
+/** @return {boolean} Whether this value is odd. */
+goog.math.Long.prototype.isOdd = function() {
+    return (this.low_ & 1) == 1;
+};
+
+
+/**
+ * @param {goog.math.Long} other Long to compare against.
+ * @return {boolean} Whether this Long equals the other.
+ */
+goog.math.Long.prototype.equals = function(other) {
+    return (this.high_ == other.high_) && (this.low_ == other.low_);
+};
+
+
+/**
+ * @param {goog.math.Long} other Long to compare against.
+ * @return {boolean} Whether this Long does not equal the other.
+ */
+goog.math.Long.prototype.notEquals = function(other) {
+    return (this.high_ != other.high_) || (this.low_ != other.low_);
+};
+
+
+/**
+ * @param {goog.math.Long} other Long to compare against.
+ * @return {boolean} Whether this Long is less than the other.
+ */
+goog.math.Long.prototype.lessThan = function(other) {
+    return this.compare(other) < 0;
+};
+
+
+/**
+ * @param {goog.math.Long} other Long to compare against.
+ * @return {boolean} Whether this Long is less than or equal to the other.
+ */
+goog.math.Long.prototype.lessThanOrEqual = function(other) {
+    return this.compare(other) <= 0;
+};
+
+
+/**
+ * @param {goog.math.Long} other Long to compare against.
+ * @return {boolean} Whether this Long is greater than the other.
+ */
+goog.math.Long.prototype.greaterThan = function(other) {
+    return this.compare(other) > 0;
+};
+
+
+/**
+ * @param {goog.math.Long} other Long to compare against.
+ * @return {boolean} Whether this Long is greater than or equal to the other.
+ */
+goog.math.Long.prototype.greaterThanOrEqual = function(other) {
+    return this.compare(other) >= 0;
+};
+
+
+/**
+ * Compares this Long with the given one.
+ * @param {goog.math.Long} other Long to compare against.
+ * @return {number} 0 if they are the same, 1 if the this is greater, and -1
+ *     if the given one is greater.
+ */
+goog.math.Long.prototype.compare = function(other) {
+    if (this.equals(other)) {
+        return 0;
+    }
+
+    var thisNeg = this.isNegative();
+    var otherNeg = other.isNegative();
+    if (thisNeg && !otherNeg) {
+        return -1;
+    }
+    if (!thisNeg && otherNeg) {
+        return 1;
+    }
+
+    // at this point, the signs are the same, so subtraction will not overflow
+    if (this.subtract(other).isNegative()) {
+        return -1;
+    } else {
+        return 1;
+    }
+};
+
+
+/** @return {!goog.math.Long} The negation of this value. */
+goog.math.Long.prototype.negate = function() {
+    if (this.equals(goog.math.Long.MIN_VALUE)) {
+        return goog.math.Long.MIN_VALUE;
+    } else {
+        return this.not().add(goog.math.Long.ONE);
+    }
+};
+
+
+/**
+ * Returns the sum of this and the given Long.
+ * @param {goog.math.Long} other Long to add to this one.
+ * @return {!goog.math.Long} The sum of this and the given Long.
+ */
+goog.math.Long.prototype.add = function(other) {
+    // Divide each number into 4 chunks of 16 bits, and then sum the chunks.
+
+    var a48 = this.high_ >>> 16;
+    var a32 = this.high_ & 0xFFFF;
+    var a16 = this.low_ >>> 16;
+    var a00 = this.low_ & 0xFFFF;
+
+    var b48 = other.high_ >>> 16;
+    var b32 = other.high_ & 0xFFFF;
+    var b16 = other.low_ >>> 16;
+    var b00 = other.low_ & 0xFFFF;
+
+    var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
+    c00 += a00 + b00;
+    c16 += c00 >>> 16;
+    c00 &= 0xFFFF;
+    c16 += a16 + b16;
+    c32 += c16 >>> 16;
+    c16 &= 0xFFFF;
+    c32 += a32 + b32;
+    c48 += c32 >>> 16;
+    c32 &= 0xFFFF;
+    c48 += a48 + b48;
+    c48 &= 0xFFFF;
+    return goog.math.Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
+};
+
+
+/**
+ * Returns the difference of this and the given Long.
+ * @param {goog.math.Long} other Long to subtract from this.
+ * @return {!goog.math.Long} The difference of this and the given Long.
+ */
+goog.math.Long.prototype.subtract = function(other) {
+    return this.add(other.negate());
+};
+
+
+/**
+ * Returns the product of this and the given long.
+ * @param {goog.math.Long} other Long to multiply with this.
+ * @return {!goog.math.Long} The product of this and the other.
+ */
+goog.math.Long.prototype.multiply = function(other) {
+    if (this.isZero()) {
+        return goog.math.Long.ZERO;
+    } else if (other.isZero()) {
+        return goog.math.Long.ZERO;
+    }
+
+    if (this.equals(goog.math.Long.MIN_VALUE)) {
+        return other.isOdd() ? goog.math.Long.MIN_VALUE : goog.math.Long.ZERO;
+    } else if (other.equals(goog.math.Long.MIN_VALUE)) {
+        return this.isOdd() ? goog.math.Long.MIN_VALUE : goog.math.Long.ZERO;
+    }
+
+    if (this.isNegative()) {
+        if (other.isNegative()) {
+            return this.negate().multiply(other.negate());
+        } else {
+            return this.negate().multiply(other).negate();
+        }
+    } else if (other.isNegative()) {
+        return this.multiply(other.negate()).negate();
+    }
+
+    // If both longs are small, use float multiplication
+    if (this.lessThan(goog.math.Long.TWO_PWR_24_) &&
+        other.lessThan(goog.math.Long.TWO_PWR_24_)) {
+        return goog.math.Long.fromNumber(this.toNumber() * other.toNumber());
+    }
+
+    // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.
+    // We can skip products that would overflow.
+
+    var a48 = this.high_ >>> 16;
+    var a32 = this.high_ & 0xFFFF;
+    var a16 = this.low_ >>> 16;
+    var a00 = this.low_ & 0xFFFF;
+
+    var b48 = other.high_ >>> 16;
+    var b32 = other.high_ & 0xFFFF;
+    var b16 = other.low_ >>> 16;
+    var b00 = other.low_ & 0xFFFF;
+
+    var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
+    c00 += a00 * b00;
+    c16 += c00 >>> 16;
+    c00 &= 0xFFFF;
+    c16 += a16 * b00;
+    c32 += c16 >>> 16;
+    c16 &= 0xFFFF;
+    c16 += a00 * b16;
+    c32 += c16 >>> 16;
+    c16 &= 0xFFFF;
+    c32 += a32 * b00;
+    c48 += c32 >>> 16;
+    c32 &= 0xFFFF;
+    c32 += a16 * b16;
+    c48 += c32 >>> 16;
+    c32 &= 0xFFFF;
+    c32 += a00 * b32;
+    c48 += c32 >>> 16;
+    c32 &= 0xFFFF;
+    c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
+    c48 &= 0xFFFF;
+    return goog.math.Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
+};
+
+
+/**
+ * Returns this Long divided by the given one.
+ * @param {goog.math.Long} other Long by which to divide.
+ * @return {!goog.math.Long} This Long divided by the given one.
+ */
+goog.math.Long.prototype.div = function(other) {
+    if (other.isZero()) {
+        throw Error('division by zero');
+    } else if (this.isZero()) {
+        return goog.math.Long.ZERO;
+    }
+
+    if (this.equals(goog.math.Long.MIN_VALUE)) {
+        if (other.equals(goog.math.Long.ONE) ||
+            other.equals(goog.math.Long.NEG_ONE)) {
+            return goog.math.Long.MIN_VALUE;  // recall that -MIN_VALUE == MIN_VALUE
+        } else if (other.equals(goog.math.Long.MIN_VALUE)) {
+            return goog.math.Long.ONE;
+        } else {
+            // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.
+            var halfThis = this.shiftRight(1);
+            var approx = halfThis.div(other).shiftLeft(1);
+            if (approx.equals(goog.math.Long.ZERO)) {
+                return other.isNegative() ? goog.math.Long.ONE : goog.math.Long.NEG_ONE;
+            } else {
+                var rem = this.subtract(other.multiply(approx));
+                var result = approx.add(rem.div(other));
+                return result;
+            }
+        }
+    } else if (other.equals(goog.math.Long.MIN_VALUE)) {
+        return goog.math.Long.ZERO;
+    }
+
+    if (this.isNegative()) {
+        if (other.isNegative()) {
+            return this.negate().div(other.negate());
+        } else {
+            return this.negate().div(other).negate();
+        }
+    } else if (other.isNegative()) {
+        return this.div(other.negate()).negate();
+    }
+
+    // Repeat the following until the remainder is less than other:  find a
+    // floating-point that approximates remainder / other *from below*, add this
+    // into the result, and subtract it from the remainder.  It is critical that
+    // the approximate value is less than or equal to the real value so that the
+    // remainder never becomes negative.
+    var res = goog.math.Long.ZERO;
+    var rem = this;
+    while (rem.greaterThanOrEqual(other)) {
+        // Approximate the result of division. This may be a little greater or
+        // smaller than the actual value.
+        var approx = Math.max(1, Math.floor(rem.toNumber() / other.toNumber()));
+
+        // We will tweak the approximate result by changing it in the 48-th digit or
+        // the smallest non-fractional digit, whichever is larger.
+        var log2 = Math.ceil(Math.log(approx) / Math.LN2);
+        var delta = (log2 <= 48) ? 1 : Math.pow(2, log2 - 48);
+
+        // Decrease the approximation until it is smaller than the remainder.  Note
+        // that if it is too large, the product overflows and is negative.
+        var approxRes = goog.math.Long.fromNumber(approx);
+        var approxRem = approxRes.multiply(other);
+        while (approxRem.isNegative() || approxRem.greaterThan(rem)) {
+            approx -= delta;
+            approxRes = goog.math.Long.fromNumber(approx);
+            approxRem = approxRes.multiply(other);
+        }
+
+        // We know the answer can't be zero... and actually, zero would cause
+        // infinite recursion since we would make no progress.
+        if (approxRes.isZero()) {
+            approxRes = goog.math.Long.ONE;
+        }
+
+        res = res.add(approxRes);
+        rem = rem.subtract(approxRem);
+    }
+    return res;
+};
+
+
+/**
+ * Returns this Long modulo the given one.
+ * @param {goog.math.Long} other Long by which to mod.
+ * @return {!goog.math.Long} This Long modulo the given one.
+ */
+goog.math.Long.prototype.modulo = function(other) {
+    return this.subtract(this.div(other).multiply(other));
+};
+
+
+/** @return {!goog.math.Long} The bitwise-NOT of this value. */
+goog.math.Long.prototype.not = function() {
+    return goog.math.Long.fromBits(~this.low_, ~this.high_);
+};
+
+
+/**
+ * Returns the bitwise-AND of this Long and the given one.
+ * @param {goog.math.Long} other The Long with which to AND.
+ * @return {!goog.math.Long} The bitwise-AND of this and the other.
+ */
+goog.math.Long.prototype.and = function(other) {
+    return goog.math.Long.fromBits(this.low_ & other.low_,
+        this.high_ & other.high_);
+};
+
+
+/**
+ * Returns the bitwise-OR of this Long and the given one.
+ * @param {goog.math.Long} other The Long with which to OR.
+ * @return {!goog.math.Long} The bitwise-OR of this and the other.
+ */
+goog.math.Long.prototype.or = function(other) {
+    return goog.math.Long.fromBits(this.low_ | other.low_,
+        this.high_ | other.high_);
+};
+
+
+/**
+ * Returns the bitwise-XOR of this Long and the given one.
+ * @param {goog.math.Long} other The Long with which to XOR.
+ * @return {!goog.math.Long} The bitwise-XOR of this and the other.
+ */
+goog.math.Long.prototype.xor = function(other) {
+    return goog.math.Long.fromBits(this.low_ ^ other.low_,
+        this.high_ ^ other.high_);
+};
+
+
+/**
+ * Returns this Long with bits shifted to the left by the given amount.
+ * @param {number} numBits The number of bits by which to shift.
+ * @return {!goog.math.Long} This shifted to the left by the given amount.
+ */
+goog.math.Long.prototype.shiftLeft = function(numBits) {
+    numBits &= 63;
+    if (numBits == 0) {
+        return this;
+    } else {
+        var low = this.low_;
+        if (numBits < 32) {
+            var high = this.high_;
+            return goog.math.Long.fromBits(
+                low << numBits,
+                (high << numBits) | (low >>> (32 - numBits)));
+        } else {
+            return goog.math.Long.fromBits(0, low << (numBits - 32));
+        }
+    }
+};
+
+
+/**
+ * Returns this Long with bits shifted to the right by the given amount.
+ * @param {number} numBits The number of bits by which to shift.
+ * @return {!goog.math.Long} This shifted to the right by the given amount.
+ */
+goog.math.Long.prototype.shiftRight = function(numBits) {
+    numBits &= 63;
+    if (numBits == 0) {
+        return this;
+    } else {
+        var high = this.high_;
+        if (numBits < 32) {
+            var low = this.low_;
+            return goog.math.Long.fromBits(
+                (low >>> numBits) | (high << (32 - numBits)),
+                high >> numBits);
+        } else {
+            return goog.math.Long.fromBits(
+                high >> (numBits - 32),
+                high >= 0 ? 0 : -1);
+        }
+    }
+};
+
+
+/**
+ * Returns this Long with bits shifted to the right by the given amount, with
+ * zeros placed into the new leading bits.
+ * @param {number} numBits The number of bits by which to shift.
+ * @return {!goog.math.Long} This shifted to the right by the given amount, with
+ *     zeros placed into the new leading bits.
+ */
+goog.math.Long.prototype.shiftRightUnsigned = function(numBits) {
+    numBits &= 63;
+    if (numBits == 0) {
+        return this;
+    } else {
+        var high = this.high_;
+        if (numBits < 32) {
+            var low = this.low_;
+            return goog.math.Long.fromBits(
+                (low >>> numBits) | (high << (32 - numBits)),
+                high >>> numBits);
+        } else if (numBits == 32) {
+            return goog.math.Long.fromBits(high, 0);
+        } else {
+            return goog.math.Long.fromBits(high >>> (numBits - 32), 0);
+        }
+    }
+};
+
+module.exports = goog.math.Long;

node_modules/bytebuffer/node_modules/long/tests/suite.js

@@ -0,0 +1,195 @@
+/*
+ Copyright 2013 Daniel Wirtz <dcode@dcode.io>
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS-IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+var Long = require(__dirname+"/../index.js"),
+    gmLong = require("./goog.math.long.js");
+
+var suite = {
+    
+    "basic": function(test) {
+        var longVal = new Long(0xFFFFFFFF, 0x7FFFFFFF);
+        test.equal(longVal.toNumber(), 9223372036854775807);
+        test.equal(longVal.toString(), "9223372036854775807");
+        var longVal2 = Long.fromValue(longVal);
+        test.equal(longVal2.toNumber(), 9223372036854775807);
+        test.equal(longVal2.toString(), "9223372036854775807");
+        test.equal(longVal2.unsigned, longVal.unsigned);
+        test.done();
+    },
+
+    "isLong": function(test) {
+        var longVal = new Long(0xFFFFFFFF, 0x7FFFFFFF);
+        test.strictEqual(Long.isLong(longVal), true);
+        longVal = {"__isLong__": true};
+        test.strictEqual(Long.isLong(longVal), true);
+        test.done();
+    },
+    
+    // Let's assume goog.math.Long has been tested properly and focus on our extensions:
+    
+    "toString": function(test) {
+        var longVal = Long.fromBits(0xFFFFFFFF, 0xFFFFFFFF, true);
+        // #10
+        test.equal(longVal.toString(16), "ffffffffffffffff");
+        test.equal(longVal.toString(10), "18446744073709551615");
+        test.equal(longVal.toString(8), "1777777777777777777777");
+        // #7, obviously wrong in goog.math.Long
+        test.equal(Long.fromString("zzzzzz", 36).toString(36), "zzzzzz");
+        test.equal(Long.fromString("-zzzzzz", 36).toString(36), "-zzzzzz");
+        test.done();
+    },
+
+    "toBytes": function(test) {
+        var longVal = Long.fromBits(0x01234567, 0x12345678);
+        test.deepEqual(longVal.toBytesBE(), [
+            0x12, 0x34, 0x56, 0x78,
+            0x01, 0x23, 0x45, 0x67
+        ]);
+        test.deepEqual(longVal.toBytesLE(), [
+            0x67, 0x45, 0x23, 0x01,
+            0x78, 0x56, 0x34, 0x12
+        ]);
+        test.done();
+    },
+    
+    "unsigned": {
+        
+        "min/max": function(test) {
+            test.equal(Long.MIN_VALUE.toString(), "-9223372036854775808");
+            test.equal(Long.MAX_VALUE.toString(), "9223372036854775807");
+            test.equal(Long.MAX_UNSIGNED_VALUE.toString(), "18446744073709551615");
+            test.done();
+        },
+        
+        "construct_negint": function(test) {
+            var longVal = Long.fromInt(-1, true);
+            test.equal(longVal.low, -1);
+            test.equal(longVal.high, -1);
+            test.equal(longVal.unsigned, true);
+            test.equal(longVal.toNumber(), 18446744073709551615);
+            test.equal(longVal.toString(), "18446744073709551615");
+            test.done();
+        },
+        
+        "construct_highlow": function(test) {
+            var longVal = new Long(0xFFFFFFFF, 0xFFFFFFFF, true);
+            test.equal(longVal.low, -1);
+            test.equal(longVal.high, -1);
+            test.equal(longVal.unsigned, true);
+            test.equal(longVal.toNumber(), 18446744073709551615);
+            test.equal(longVal.toString(), "18446744073709551615");
+            test.done();
+        },
+        
+        "construct_number": function(test) {
+            var longVal = Long.fromNumber(0xFFFFFFFFFFFFFFFF, true);
+            test.equal(longVal.low, -1);
+            test.equal(longVal.high, -1);
+            test.equal(longVal.unsigned, true);
+            test.equal(longVal.toNumber(), 18446744073709551615);
+            test.equal(longVal.toString(), "18446744073709551615");
+            test.done();
+        },
+
+        "toSigned/Unsigned": function(test) {
+            var longVal = Long.fromNumber(-1, false);
+            test.equal(longVal.toNumber(), -1);
+            longVal = longVal.toUnsigned();
+            test.equal(longVal.toNumber(), 0xFFFFFFFFFFFFFFFF);
+            test.equal(longVal.toString(16), 'ffffffffffffffff');
+            longVal = longVal.toSigned();
+            test.equal(longVal.toNumber(), -1);
+            test.done();
+        },
+        
+        "max_unsigned_sub_max_signed": function(test) {
+            var longVal = Long.MAX_UNSIGNED_VALUE.subtract(Long.MAX_VALUE).subtract(Long.ONE);
+            test.equal(longVal.toNumber(), Long.MAX_VALUE.toNumber());
+            test.equal(longVal.toString(), Long.MAX_VALUE.toString());
+            test.done();
+        },
+        
+        "max_sub_max": function(test) {
+            var longVal = Long.MAX_UNSIGNED_VALUE.subtract(Long.MAX_UNSIGNED_VALUE);
+            test.equal(longVal, 0);
+            test.equal(longVal.low, 0);
+            test.equal(longVal.high, 0);
+            test.equal(longVal.unsigned, true);
+            test.equal(longVal.toNumber(), 0);
+            test.equal(longVal.toString(), "0");
+            test.done();
+        },
+        
+        "zero_sub_signed": function(test) {
+            var longVal = Long.fromInt(0, true).add(Long.fromInt(-1, false));
+            test.equal(longVal.low, -1);
+            test.equal(longVal.high, -1);
+            test.equal(longVal.unsigned, true);
+            test.equal(longVal.toNumber(), 18446744073709551615);
+            test.equal(longVal.toString(), "18446744073709551615");
+            test.done();
+        },
+        
+        "max_unsigned_div_max_signed": function(test) {
+            var longVal = Long.MAX_UNSIGNED_VALUE.div(Long.MAX_VALUE);
+            test.equal(longVal.toNumber(), 2);
+            test.equal(longVal.toString(), "2");
+            test.done();
+        },
+        
+        "max_unsigned_div_max_unsigned": function(test) {
+            var longVal = Long.MAX_UNSIGNED_VALUE;
+            test.strictEqual(longVal.div(longVal).toString(), '1');
+            test.done();
+        },
+        
+        "max_unsigned_div_neg_signed": function(test) {
+            var a = Long.MAX_UNSIGNED_VALUE;
+            var b = Long.fromInt(-2);
+            test.strictEqual(b.toUnsigned().toString(), Long.MAX_UNSIGNED_VALUE.sub(1).toString());
+            var longVal = a.div(b);
+            test.strictEqual(longVal.toString(), '1');
+            test.done();
+        },
+
+        "min_signed_div_one": function(test) {
+            var longVal = Long.MIN_VALUE.div(Long.ONE);
+            test.strictEqual(longVal.toString(), Long.MIN_VALUE.toString());
+            test.done();
+        },
+
+        "msb_unsigned": function(test) {
+            var longVal = Long.UONE.shiftLeft(63);
+            test.ok(longVal.notEquals(Long.MIN_VALUE));
+            test.equal(longVal.toString(), "9223372036854775808");
+            test.equal(Long.fromString("9223372036854775808", true).toString(), "9223372036854775808");
+            test.done();
+        },
+        
+        "issue31": function(test) {
+            var a = new Long(0, 8, true);
+            var b = Long.fromNumber(2656901066, true);
+            test.strictEqual(a.unsigned, true);
+            test.strictEqual(b.unsigned, true);
+            var x = a.div(b);
+            test.strictEqual(x.toString(), '12');
+            test.strictEqual(x.unsigned, true);
+            test.done();
+        }
+    }
+};
+
+module.exports = suite;