carrydela/hcapEnv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

415gotit

Browse Source
This commit is contained in:
dela
2026-02-21 18:27:49 +08:00
parent 0ac4b23f07
commit 5dc86ccfbf
270 changed files with 49508 additions and 4636 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
node_modules/msgpack-lite/.npmignore generated vendored Normal file
View File

@@ -0,0 +1,8 @@
*~
.DS_Store
.idea/
node_modules/
*.browserify.js
*.js.gz
gh-pages/
*.log

26
node_modules/msgpack-lite/.travis.yml generated vendored Normal file
View File

@@ -0,0 +1,26 @@
sudo: false
language: node_js
matrix:
include:
- node_js: "0.12"
env: BROWSER=1
- node_js: "0.10"
- node_js: "0.12"
- node_js: "4"
- node_js: "5"
- node_js: "6"
env:
global:
- CXX=g++-4.8
- secure: P5H38v7QLRCYOWZkDKkl5ubJK0WxaAeVPDqbRlZDXbzEthjNf/rVMF6vnjyssbgbujTaU7xJmnVXKxjKtwAZXRrv3D9pmqqAOXdBNxaIs+Y05exA0pPBfBQNxVWKx6jbCoW7a12yWBreOAVd7sqjT86Plr2LsLM72BLaSl2v+18wOAnxYPFdDTEU17DegDUeQfmt+qFVNIUfuLcHyuiNFnLisWjhJmm3JmcjBL2WuSj2JC5Qll/zr7ezZns8qzqXqFsRRkLie4nVERV0kXvZRH5t5iB9444vwXhkVcOa2HSH+aVEDXoRVkj7JLmvYBGay/DKrGUDST91f7d5DpNYwZYNi5YHfpySaEEM8RDd+TM7oHr2YeWykqjBv4lfqVq3t9WFpC3YvLujaTNtNh01P24jvx81/XCKYWtYmBeGD7I8lVmFbOt7JNRSvfz2kP5qT47AIj3bpSBfouhntOVPkFz+e3pvK4w8wBBOLhRgXaFJZnE5IK5CRqNuEps/dBmAk5ANwoTewtLXmr2pJXVBBKmaj6E/1EmOb3KBC8F5yqid4UWJMgGK9g+QtY24mYfkIB5mldK5t9sePtNxkEqfxPO22IS7CEydr/LCB6g5zftcy7WN28DhCr3UbAC9Ydsa1k8LFsgznQ0sfyxOi/8c6lOdCLR947elLy5tAaemi20=
- secure: Lqm+pi1xprYlJurnEGmShpcohkWh7BwT2WvZXbfTwFH4K1BQIzbTbmhdkBTpfrJzF05q0zUGvYOTOpmz4K0JKsJfCdrjjEkpsZxTMrOvJG/C0aDLAsaiOtXTNA4unjL4qlaOA82btry6ATOsxYDWyYtjQKBUJvFEYgjBUkLarWxywU7cw8OcL4ICfHjFVA4ODvOmxUQ9ESCc1E6JkacjyprVx5gmrzEfN0JL6wcaXewt7prx02U5iDFONkntpx8VEhTwBGM2nWGzbPgiuRfOV879YXkPPWUNJc/P1Q8r8T3hvFGmg2b1x8aNZ60ir64ArXannsQhJB3rZ15rp5cAptuhMAMuuc+aF0z0VIDVStSNsLxWa/u6pH8ctMvHokrguFUSpQpduOdke/B4y719fRLUS3IW98Z10+dw0LQUn1TDmryK4ELy0IDLYPNeJJ0NoaUCv7a6OT22II085iAjGw+vMaiTm/3MRIe4kjIg2jJaCsYUZ1VFW9O/0aqtUpjuHmLg0cAxfrjBW/+sexhfO3/Ea6NCmTjaC9T7fB5YzCiEvYCHRoDUj1aloYvMBog8eE0BvDLCtbwqGBIwa5G9TEfu1ywJLQPmRXf1U1c5HUvUc+P82XOX1fs0AeeskHRSkIBLkuzYXQNcp6hU3Iy1/FOClBcAdHSi3OExJdSFHHo=
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- g++-4.8

20
node_modules/msgpack-lite/.zuul.yml generated vendored Normal file
View File

@@ -0,0 +1,20 @@
sauce_username: msgpack-lite
sauce_key: "32947ef3-a727-4848-9aee-cebe65df3be4"
name: msgpack-lite
ui: mocha-bdd
html: "test/zuul/ie.html"
scripts:
- "dist/msgpack.min.js"
browsers:
- name: ie
version: "9..latest"
- name: chrome
version: "latest"
- name: firefox
version: "latest"
- name: safari
version: "7..latest"
- name: iphone
version: ["7.1", "8.4", "9.3..latest"]
- name: android
version: ["4.1", "4.4", "5.1..latest"]

22
node_modules/msgpack-lite/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,22 @@
The MIT License (MIT)
Copyright (c) 2015 Yusuke Kawasaki
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

48
node_modules/msgpack-lite/Makefile generated vendored Executable file
View File

@@ -0,0 +1,48 @@
#!/usr/bin/env bash -c make
SRC=./lib/browser.js
LIB=./index.js ./lib/*.js
TESTS=./test/*.js
TESTS_BROWSER=./test/[12]?.*.js
HINTS=$(LIB) $(TESTS) ./*.json ./test/*.json
CLASS=msgpack
DIST=./dist
JSTEMP=./dist/msgpack.browserify.js
JSDEST=./dist/msgpack.min.js
all: test $(JSDEST)
clean:
rm -fr $(JSDEST) $(JSTEMP)
$(DIST):
mkdir -p $(DIST)
$(JSTEMP): $(LIB) $(DIST)
./node_modules/.bin/browserify -s $(CLASS) $(SRC) -o $(JSTEMP) --debug
$(JSDEST): $(JSTEMP)
./node_modules/.bin/uglifyjs $(JSTEMP) -c -m -r Buffer -o $(JSDEST)
ls -l $(JSDEST)
test:
@if [ "x$(BROWSER)" = "x" ]; then make test-node; else make test-browser; fi
mocha:
./node_modules/.bin/mocha -R spec $(TESTS)
jshint:
./node_modules/.bin/jshint $(HINTS)
test-node: jshint mocha
test-browser: $(JSDEST)
./node_modules/.bin/zuul -- $(TESTS_BROWSER)
test-browser-local: $(JSDEST)
./node_modules/.bin/zuul --local 4000 -- $(TESTS_BROWSER)
bench:
node lib/benchmark.js 1
.PHONY: all clean test jshint mocha bench test-node test-browser test-browser-local

433
node_modules/msgpack-lite/README.md generated vendored Normal file
View File

@@ -0,0 +1,433 @@
# msgpack-lite [![npm version](https://badge.fury.io/js/msgpack-lite.svg)](http://badge.fury.io/js/msgpack-lite) [![Build Status](https://travis-ci.org/kawanet/msgpack-lite.svg?branch=master)](https://travis-ci.org/kawanet/msgpack-lite)
Fast Pure JavaScript MessagePack Encoder and Decoder
[![Sauce Test Status](https://saucelabs.com/browser-matrix/msgpack-lite.svg)](https://saucelabs.com/u/msgpack-lite)
Online demo: [http://kawanet.github.io/msgpack-lite/](http://kawanet.github.io/msgpack-lite/)
### Features
- Pure JavaScript only (No node-gyp nor gcc required)
- Faster than any other pure JavaScript libraries on node.js v4
- Even faster than node-gyp C++ based [msgpack](https://www.npmjs.com/package/msgpack) library (**90% faster** on encoding)
- Streaming encoding and decoding interface is also available. It's more faster.
- Ready for [Web browsers](https://saucelabs.com/u/msgpack-lite) including Chrome, Firefox, Safari and even IE8
- [Tested](https://travis-ci.org/kawanet/msgpack-lite) on Node.js v0.10, v0.12, v4, v5 and v6 as well as Web browsers
### Encoding and Decoding MessagePack
```js
var msgpack = require("msgpack-lite");
// encode from JS Object to MessagePack (Buffer)
var buffer = msgpack.encode({"foo": "bar"});
// decode from MessagePack (Buffer) to JS Object
var data = msgpack.decode(buffer); // => {"foo": "bar"}
// if encode/decode receives an invalid argument an error is thrown
```
### Writing to MessagePack Stream
```js
var fs = require("fs");
var msgpack = require("msgpack-lite");
var writeStream = fs.createWriteStream("test.msp");
var encodeStream = msgpack.createEncodeStream();
encodeStream.pipe(writeStream);
// send multiple objects to stream
encodeStream.write({foo: "bar"});
encodeStream.write({baz: "qux"});
// call this once you're done writing to the stream.
encodeStream.end();
```
### Reading from MessagePack Stream
```js
var fs = require("fs");
var msgpack = require("msgpack-lite");
var readStream = fs.createReadStream("test.msp");
var decodeStream = msgpack.createDecodeStream();
// show multiple objects decoded from stream
readStream.pipe(decodeStream).on("data", console.warn);
```
### Decoding MessagePack Bytes Array
```js
var msgpack = require("msgpack-lite");
// decode() accepts Buffer instance per default
msgpack.decode(Buffer([0x81, 0xA3, 0x66, 0x6F, 0x6F, 0xA3, 0x62, 0x61, 0x72]));
// decode() also accepts Array instance
msgpack.decode([0x81, 0xA3, 0x66, 0x6F, 0x6F, 0xA3, 0x62, 0x61, 0x72]);
// decode() accepts raw Uint8Array instance as well
msgpack.decode(new Uint8Array([0x81, 0xA3, 0x66, 0x6F, 0x6F, 0xA3, 0x62, 0x61, 0x72]));
```
### Command Line Interface
A CLI tool bin/msgpack converts data stream from JSON to MessagePack and vice versa.
```sh
$ echo '{"foo": "bar"}' | ./bin/msgpack -Jm | od -tx1
0000000 81 a3 66 6f 6f a3 62 61 72
$ echo '{"foo": "bar"}' | ./bin/msgpack -Jm | ./bin/msgpack -Mj
{"foo":"bar"}
```
### Installation
```sh
$ npm install --save msgpack-lite
```
### Tests
Run tests on node.js:
```sh
$ make test
```
Run tests on browsers:
```sh
$ make test-browser-local
open the following url in a browser:
http://localhost:4000/__zuul
```
### Browser Build
Browser version [msgpack.min.js](https://rawgit.com/kawanet/msgpack-lite/master/dist/msgpack.min.js) is also available. 50KB minified, 14KB gziped.
```html
<!--[if lte IE 9]>
<script src="https://cdnjs.cloudflare.com/ajax/libs/es5-shim/4.1.10/es5-shim.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/json3/3.3.2/json3.min.js"></script>
<![endif]-->
<script src="https://rawgit.com/kawanet/msgpack-lite/master/dist/msgpack.min.js"></script>
<script>
// encode from JS Object to MessagePack (Uint8Array)
var buffer = msgpack.encode({foo: "bar"});
// decode from MessagePack (Uint8Array) to JS Object
var array = new Uint8Array([0x81, 0xA3, 0x66, 0x6F, 0x6F, 0xA3, 0x62, 0x61, 0x72]);
var data = msgpack.decode(array);
</script>
```
### MessagePack With Browserify
Step #1: write some code at first.
```js
var msgpack = require("msgpack-lite");
var buffer = msgpack.encode({"foo": "bar"});
var data = msgpack.decode(buffer);
console.warn(data); // => {"foo": "bar"}
```
Proceed to the next steps if you prefer faster browserify compilation time.
Step #2: add `browser` property on `package.json` in your project. This refers the global `msgpack` object instead of including whole of `msgpack-lite` source code.
```json
{
"dependencies": {
"msgpack-lite": "*"
},
"browser": {
"msgpack-lite": "msgpack-lite/global"
}
}
```
Step #3: compile it with [browserify](https://www.npmjs.com/package/browserify) and [uglifyjs](https://www.npmjs.com/package/uglify-js).
```sh
browserify src/main.js -o tmp/main.browserify.js -s main
uglifyjs tmp/main.browserify.js -m -c -o js/main.min.js
cp node_modules/msgpack-lite/dist/msgpack.min.js js/msgpack.min.js
```
Step #4: load [msgpack.min.js](https://rawgit.com/kawanet/msgpack-lite/master/dist/msgpack.min.js) before your code.
```html
<script src="js/msgpack.min.js"></script>
<script src="js/main.min.js"></script>
```
### Interoperability
It is tested to have basic compatibility with other Node.js MessagePack modules below:
- [https://www.npmjs.com/package/msgpack](https://www.npmjs.com/package/msgpack) (1.0.2)
- [https://www.npmjs.com/package/msgpack-js](https://www.npmjs.com/package/msgpack-js) (0.3.0)
- [https://www.npmjs.com/package/msgpack-js-v5](https://www.npmjs.com/package/msgpack-js-v5) (0.3.0-v5)
- [https://www.npmjs.com/package/msgpack-unpack](https://www.npmjs.com/package/msgpack-unpack) (2.1.1)
- [https://github.com/msgpack/msgpack-javascript](https://github.com/msgpack/msgpack-javascript) (msgpack.codec)
- [https://www.npmjs.com/package/msgpack5](https://www.npmjs.com/package/msgpack5) (3.3.0)
- [https://www.npmjs.com/package/notepack](https://www.npmjs.com/package/notepack) (0.0.2)
### Benchmarks
A benchmark tool `lib/benchmark.js` is available to compare encoding/decoding speed
(operation per second) with other MessagePack modules.
It counts operations of [1KB JSON document](https://github.com/kawanet/msgpack-lite/blob/master/test/example.json) in 10 seconds.
```sh
$ npm install msgpack msgpack-js msgpack-js-v5 msgpack-unpack msgpack5 notepack
$ npm run benchmark 10
```
operation | op | ms | op/s
--------------------------------------------------------- | -----: | ----: | -----:
buf = Buffer(JSON.stringify(obj)); | 1055200 | 10000 | 105520
obj = JSON.parse(buf); | 863800 | 10000 | 86380
buf = require("msgpack-lite").encode(obj); | 969100 | 10000 | 96910
obj = require("msgpack-lite").decode(buf); | 600300 | 10000 | 60030
buf = require("msgpack").pack(obj); | 503500 | 10001 | 50344
obj = require("msgpack").unpack(buf); | 560200 | 10001 | 56014
buf = Buffer(require("msgpack.codec").msgpack.pack(obj)); | 653500 | 10000 | 65349
obj = require("msgpack.codec").msgpack.unpack(buf); | 367500 | 10001 | 36746
buf = require("msgpack-js-v5").encode(obj); | 189500 | 10002 | 18946
obj = require("msgpack-js-v5").decode(buf); | 408900 | 10000 | 40890
buf = require("msgpack-js").encode(obj); | 189200 | 10000 | 18920
obj = require("msgpack-js").decode(buf); | 375600 | 10002 | 37552
buf = require("msgpack5")().encode(obj); | 110500 | 10009 | 11040
obj = require("msgpack5")().decode(buf); | 165500 | 10000 | 16550
buf = require("notepack")().encode(obj); | 847800 | 10000 | 84780
obj = require("notepack")().decode(buf); | 599800 | 10000 | 59980
obj = require("msgpack-unpack").decode(buf); | 48100 | 10002 | 4809
Streaming benchmark tool `lib/benchmark-stream.js` is also available.
It counts milliseconds for 1,000,000 operations of 30 bytes fluentd msgpack fragment.
This shows streaming encoding and decoding are super faster.
```sh
$ npm run benchmark-stream 2
```
operation (1000000 x 2) | op | ms | op/s
------------------------------------------------ | ------: | ----: | -----:
stream.write(msgpack.encode(obj)); | 1000000 | 3027 | 330360
stream.write(notepack.encode(obj)); | 1000000 | 2012 | 497017
msgpack.Encoder().on("data",ondata).encode(obj); | 1000000 | 2956 | 338294
msgpack.createEncodeStream().write(obj); | 1000000 | 1888 | 529661
stream.write(msgpack.decode(buf)); | 1000000 | 2020 | 495049
stream.write(notepack.decode(buf)); | 1000000 | 1794 | 557413
msgpack.Decoder().on("data",ondata).decode(buf); | 1000000 | 2744 | 364431
msgpack.createDecodeStream().write(buf); | 1000000 | 1341 | 745712
Test environment: msgpack-lite 0.1.14, Node v4.2.3, Intel(R) Xeon(R) CPU E5-2666 v3 @ 2.90GHz
### MessagePack Mapping Table
The following table shows how JavaScript objects (value) will be mapped to
[MessagePack formats](https://github.com/msgpack/msgpack/blob/master/spec.md)
and vice versa.
Source Value|MessagePack Format|Value Decoded
----|----|----
null, undefined|nil format family|null
Boolean (true, false)|bool format family|Boolean (true, false)
Number (32bit int)|int format family|Number (int or double)
Number (64bit double)|float format family|Number (double)
String|str format family|String
Buffer|bin format family|Buffer
Array|array format family|Array
Map|map format family|Map (if `usemap=true`)
Object (plain object)|map format family|Object (or Map if `usemap=true`)
Object (see below)|ext format family|Object (see below)
Note that both `null` and `undefined` are mapped to nil `0xC1` type.
This means `undefined` value will be *upgraded* to `null` in other words.
### Extension Types
The MessagePack specification allows 128 application-specific extension types.
The library uses the following types to make round-trip conversion possible
for JavaScript native objects.
Type|Object|Type|Object
----|----|----|----
0x00||0x10|
0x01|EvalError|0x11|Int8Array
0x02|RangeError|0x12|Uint8Array
0x03|ReferenceError|0x13|Int16Array
0x04|SyntaxError|0x14|Uint16Array
0x05|TypeError|0x15|Int32Array
0x06|URIError|0x16|Uint32Array
0x07||0x17|Float32Array
0x08||0x18|Float64Array
0x09||0x19|Uint8ClampedArray
0x0A|RegExp|0x1A|ArrayBuffer
0x0B|Boolean|0x1B|Buffer
0x0C|String|0x1C|
0x0D|Date|0x1D|DataView
0x0E|Error|0x1E|
0x0F|Number|0x1F|
Other extension types are mapped to built-in ExtBuffer object.
### Custom Extension Types (Codecs)
Register a custom extension type number to serialize/deserialize your own class instances.
```js
var msgpack = require("msgpack-lite");
var codec = msgpack.createCodec();
codec.addExtPacker(0x3F, MyVector, myVectorPacker);
codec.addExtUnpacker(0x3F, myVectorUnpacker);
var data = new MyVector(1, 2);
var encoded = msgpack.encode(data, {codec: codec});
var decoded = msgpack.decode(encoded, {codec: codec});
function MyVector(x, y) {
this.x = x;
this.y = y;
}
function myVectorPacker(vector) {
var array = [vector.x, vector.y];
return msgpack.encode(array); // return Buffer serialized
}
function myVectorUnpacker(buffer) {
var array = msgpack.decode(buffer);
return new MyVector(array[0], array[1]); // return Object deserialized
}
```
The first argument of `addExtPacker` and `addExtUnpacker` should be an integer within the range of 0 and 127 (0x0 and 0x7F). `myClassPacker` is a function that accepts an instance of `MyClass`, and should return a buffer representing that instance. `myClassUnpacker` is the opposite: it accepts a buffer and should return an instance of `MyClass`.
If you pass an array of functions to `addExtPacker` or `addExtUnpacker`, the value to be encoded/decoded will pass through each one in order. This allows you to do things like this:
```js
codec.addExtPacker(0x00, Date, [Number, msgpack.encode]);
```
You can also pass the `codec` option to `msgpack.Decoder(options)`, `msgpack.Encoder(options)`, `msgpack.createEncodeStream(options)`, and `msgpack.createDecodeStream(options)`.
If you wish to modify the default built-in codec, you can access it at `msgpack.codec.preset`.
### Custom Codec Options
`msgpack.createCodec()` function accepts some options.
It does NOT have the preset extension types defined when no options given.
```js
var codec = msgpack.createCodec();
```
`preset`: It has the preset extension types described above.
```js
var codec = msgpack.createCodec({preset: true});
```
`safe`: It runs a validation of the value before writing it into buffer. This is the default behavior for some old browsers which do not support `ArrayBuffer` object.
```js
var codec = msgpack.createCodec({safe: true});
```
`useraw`: It uses `raw` formats instead of `bin` and `str`.
```js
var codec = msgpack.createCodec({useraw: true});
```
`int64`: It decodes msgpack's `int64`/`uint64` formats with [int64-buffer](https://github.com/kawanet/int64-buffer) object.
```js
var codec = msgpack.createCodec({int64: true});
```
`binarraybuffer`: It ties msgpack's `bin` format with `ArrayBuffer` object, instead of `Buffer` object.
```js
var codec = msgpack.createCodec({binarraybuffer: true, preset: true});
```
`uint8array`: It returns Uint8Array object when encoding, instead of `Buffer` object.
```js
var codec = msgpack.createCodec({uint8array: true});
```
`usemap`: Uses the global JavaScript Map type, if available, to unpack
MessagePack map elements.
```js
var codec = msgpack.createCodec({usemap: true});
```
### Compatibility Mode
The [compatibility mode](https://github.com/kawanet/msgpack-lite/issues/22) respects for [msgpack's old spec](https://github.com/msgpack/msgpack/blob/master/spec-old.md). Set `true` to `useraw`.
```js
// default mode handles both str and bin formats individually
msgpack.encode("Aa"); // => <Buffer a2 41 61> (str format)
msgpack.encode(new Buffer([0x41, 0x61])); // => <Buffer c4 02 41 61> (bin format)
msgpack.decode(new Buffer([0xa2, 0x41, 0x61])); // => 'Aa' (String)
msgpack.decode(new Buffer([0xc4, 0x02, 0x41, 0x61])); // => <Buffer 41 61> (Buffer)
// compatibility mode handles only raw format both for String and Buffer
var options = {codec: msgpack.createCodec({useraw: true})};
msgpack.encode("Aa", options); // => <Buffer a2 41 61> (raw format)
msgpack.encode(new Buffer([0x41, 0x61]), options); // => <Buffer a2 41 61> (raw format)
msgpack.decode(new Buffer([0xa2, 0x41, 0x61]), options); // => <Buffer 41 61> (Buffer)
msgpack.decode(new Buffer([0xa2, 0x41, 0x61]), options).toString(); // => 'Aa' (String)
```
### Repository
- [https://github.com/kawanet/msgpack-lite](https://github.com/kawanet/msgpack-lite)
### See Also
- [http://msgpack.org/](http://msgpack.org/)
### License
The MIT License (MIT)
Copyright (c) 2015-2016 Yusuke Kawasaki
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

5
node_modules/msgpack-lite/bin/msgpack generated vendored Executable file
View File

@@ -0,0 +1,5 @@
#!/usr/bin/env node
var args = Array.prototype.slice.call(process.argv, 2);
require("../lib/cli").CLI.apply(null, args);

34
node_modules/msgpack-lite/bower.json generated vendored Normal file
View File

@@ -0,0 +1,34 @@
{
"name": "msgpack-lite",
"description": "Fast Pure JavaScript MessagePack Encoder and Decoder",
"authors": [
"@kawanet"
],
"license": "MIT",
"moduleType": [
"globals"
],
"keywords": [
"buffer",
"fluentd",
"messagepack",
"msgpack",
"serialize",
"stream",
"typedarray",
"arraybuffer",
"uint8array"
],
"homepage": "https://github.com/kawanet/msgpack-lite",
"ignore": [
".*",
"Makefile",
"bin",
"bower_components",
"global.js",
"index.js",
"lib",
"node_modules",
"test"
]
}

2
node_modules/msgpack-lite/dist/msgpack.min.js generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

2
node_modules/msgpack-lite/global.js generated vendored Normal file
View File

@@ -0,0 +1,2 @@
/* globals msgpack */
module.exports = msgpack;

13
node_modules/msgpack-lite/index.js generated vendored Normal file
View File

@@ -0,0 +1,13 @@
// msgpack.js
exports.encode = require("./lib/encode").encode;
exports.decode = require("./lib/decode").decode;
exports.Encoder = require("./lib/encoder").Encoder;
exports.Decoder = require("./lib/decoder").Decoder;
exports.createEncodeStream = require("./lib/encode-stream").createEncodeStream;
exports.createDecodeStream = require("./lib/decode-stream").createDecodeStream;
exports.createCodec = require("./lib/ext").createCodec;
exports.codec = require("./lib/codec").codec;

247
node_modules/msgpack-lite/lib/benchmark-stream.js generated vendored Executable file
View File

@@ -0,0 +1,247 @@
#!/usr/bin/env node
var PassThrough = require("stream").PassThrough;
var async = require("async");
var msgpack = require("../");
var Encoder = require("./encoder").Encoder;
var Decoder = require("./decoder").Decoder;
var notepack = require("notepack");
var pkg = require("../package.json");
// a sample fluentd message
var data = ["tag", [[1440949922, {"message": "hi there"}]]];
var packed = msgpack.encode(data); // 30 bytes per message
var packsize = packed.length;
var opcount = 1000000;
var joincount = 100;
var packjoin = repeatbuf(packed, joincount); // 3KB per chunk
var limit = 2;
var argv = Array.prototype.slice.call(process.argv, 2);
if (argv[0] === "-v") {
console.warn(pkg.name + " " + pkg.version);
process.exit(0);
}
if (argv[0] - 0) limit = argv.shift() - 0;
var list = [
['stream.write(msgpack.encode(obj));', encode1],
['stream.write(notepack.encode(obj));', encode4],
['msgpack.Encoder().on("data",ondata).encode(obj);', encode2],
['msgpack.createEncodeStream().write(obj);', encode3],
['stream.write(msgpack.decode(buf));', decode1],
['stream.write(notepack.decode(buf));', decode4],
['msgpack.Decoder().on("data",ondata).decode(buf);', decode2],
['msgpack.createDecodeStream().write(buf);', decode3]
];
function encode1(callback) {
var stream = new PassThrough();
var cnt = counter(callback);
stream.on("data", cnt.buf);
stream.on("end", cnt.end);
for (var j = 0; j < opcount; j++) {
stream.write(msgpack.encode(data));
}
stream.end();
}
function encode2(callback) {
var stream = new PassThrough();
var cnt = counter(callback);
stream.on("data", cnt.buf);
stream.on("end", cnt.end);
var encoder = Encoder();
encoder.on("data", function(chunk) {
stream.write(chunk);
});
encoder.on("end", function() {
stream.end();
});
for (var j = 0; j < opcount; j++) {
encoder.encode(data);
}
encoder.end();
}
function encode3(callback) {
var stream = msgpack.createEncodeStream();
var cnt = counter(callback);
stream.on("data", cnt.buf);
stream.on("end", cnt.end);
for (var j = 0; j < opcount; j++) {
stream.write(data);
}
stream.end();
}
function encode4(callback) {
var stream = new PassThrough();
var cnt = counter(callback);
stream.on("data", cnt.buf);
stream.on("end", cnt.end);
for (var j = 0; j < opcount; j++) {
stream.write(notepack.encode(data));
}
stream.end();
}
function decode1(callback) {
var stream = new PassThrough({objectMode: true});
var cnt = counter(callback);
stream.on("data", cnt.inc);
stream.on("end", cnt.end);
for (var j = 0; j < opcount; j++) {
stream.write(msgpack.decode(packed));
}
stream.end();
}
function decode2(callback) {
var stream = new PassThrough({objectMode: true});
var cnt = counter(callback);
stream.on("data", cnt.inc);
stream.on("end", cnt.end);
var decoder = Decoder();
decoder.on("data", function(chunk) {
stream.write(chunk);
});
decoder.on("end", function() {
stream.end();
});
for (var j = 0; j < opcount / joincount; j++) {
decoder.decode(packjoin);
}
decoder.end();
}
function decode3(callback) {
var stream = msgpack.createDecodeStream();
var cnt = counter(callback);
stream.on("data", cnt.inc);
stream.on("end", cnt.end);
for (var j = 0; j < opcount / joincount; j++) {
stream.write(packjoin);
}
stream.end();
}
function decode4(callback) {
var stream = new PassThrough({objectMode: true});
var cnt = counter(callback);
stream.on("data", cnt.inc);
stream.on("end", cnt.end);
for (var j = 0; j < opcount; j++) {
stream.write(notepack.decode(packed));
}
stream.end();
}
function rpad(str, len, chr) {
if (!chr) chr = " ";
str += "";
while (str.length < len) str += chr;
return str;
}
function lpad(str, len, chr) {
if (!chr) chr = " ";
str += "";
while (str.length < len) str = chr + str;
return str;
}
function repeatbuf(buf, cnt) {
var array = [];
for (var i = 0; i < cnt; i++) {
array.push(buf);
}
return Buffer.concat(array);
}
function counter(callback) {
var cnt = 0;
return {buf: b, inc: i, end: e};
function b(buf) {
cnt += buf.length / packsize;
}
function i() {
cnt++;
}
function e() {
cnt = Math.round(cnt);
callback(null, cnt);
}
}
function run() {
// task filter
if (argv.length) {
list = list.filter(function(pair) {
var name = pair[0];
var match = argv.filter(function(grep) {
return (name.indexOf(grep) > -1);
});
return match.length;
});
}
// run tasks repeatedly
var tasks = [];
for (var i = 0; i < limit; i++) {
tasks.push(oneset);
}
async.series(tasks, end);
// run a series of tasks
function oneset(callback) {
async.eachSeries(list, bench, callback);
}
// run a single benchmark
function bench(pair, callback) {
process.stdout.write(".");
var func = pair[1];
var start = new Date() - 0;
func(function(err, cnt) {
var end = new Date() - 0;
var array = pair[2] || (pair[2] = []);
array.push(end - start);
pair[3] = cnt;
setTimeout(callback, 100);
});
}
// show result
function end() {
var title = "operation (" + opcount + " x " + limit + ")";
process.stdout.write("\n");
// table header
var COL1 = 48;
console.log(rpad(title, COL1), "|", " op ", "|", " ms ", "|", " op/s ");
console.log(rpad("", COL1, "-"), "|", "------:", "|", "----:", "|", "-----:");
// table body
list.forEach(function(pair) {
var name = pair[0];
var op = pair[3];
var array = pair[2];
array = array.sort(function(a, b) {
return a > b;
});
var fastest = array[0];
var score = Math.floor(opcount / fastest * 1000);
console.log(rpad(name, COL1), "|", lpad(op, 7), "|", lpad(fastest, 5), "|", lpad(score, 6));
});
}
}
run();

157
node_modules/msgpack-lite/lib/benchmark.js generated vendored Executable file
View File

@@ -0,0 +1,157 @@
#!/usr/bin/env node
var msgpack_node = try_require("msgpack");
var msgpack_lite = try_require("../index");
var msgpack_js = try_require("msgpack-js");
var msgpack_js_v5 = try_require("msgpack-js-v5");
var msgpack5 = try_require("msgpack5");
var msgpack_unpack = try_require("msgpack-unpack");
var msgpack_codec = try_require("msgpack.codec");
var notepack = try_require("notepack");
msgpack5 = msgpack5 && msgpack5();
msgpack_codec = msgpack_codec && msgpack_codec.msgpack;
var pkg = require("../package.json");
var data = require("../test/example");
var packed = msgpack_lite.encode(data);
var expected = JSON.stringify(data);
var argv = Array.prototype.slice.call(process.argv, 2);
if (argv[0] === "-v") {
console.warn(pkg.name + " " + pkg.version);
process.exit(0);
}
var limit = 5;
if (argv[0] - 0) limit = argv.shift() - 0;
limit *= 1000;
var COL1 = 57;
var COL2 = 6;
var COL3 = 5;
var COL4 = 6;
console.log(rpad("operation", COL1), "|", " op ", "|", " ms ", "|", " op/s ");
console.log(rpad("", COL1, "-"), "|", lpad(":", COL2, "-"), "|", lpad(":", COL3, "-"), "|", lpad(":", COL4, "-"));
var buf, obj;
if (JSON) {
buf = bench('buf = Buffer(JSON.stringify(obj));', JSON_stringify, data);
obj = bench('obj = JSON.parse(buf);', JSON.parse, buf);
test(obj);
}
if (msgpack_lite) {
buf = bench('buf = require("msgpack-lite").encode(obj);', msgpack_lite.encode, data);
obj = bench('obj = require("msgpack-lite").decode(buf);', msgpack_lite.decode, packed);
test(obj);
}
if (msgpack_node) {
buf = bench('buf = require("msgpack").pack(obj);', msgpack_node.pack, data);
obj = bench('obj = require("msgpack").unpack(buf);', msgpack_node.unpack, buf);
test(obj);
}
if (msgpack_codec) {
buf = bench('buf = Buffer(require("msgpack.codec").msgpack.pack(obj));', msgpack_codec_pack, data);
obj = bench('obj = require("msgpack.codec").msgpack.unpack(buf);', msgpack_codec.unpack, buf);
test(obj);
}
if (msgpack_js_v5) {
buf = bench('buf = require("msgpack-js-v5").encode(obj);', msgpack_js_v5.encode, data);
obj = bench('obj = require("msgpack-js-v5").decode(buf);', msgpack_js_v5.decode, buf);
test(obj);
}
if (msgpack_js) {
buf = bench('buf = require("msgpack-js").encode(obj);', msgpack_js.encode, data);
obj = bench('obj = require("msgpack-js").decode(buf);', msgpack_js.decode, buf);
test(obj);
}
if (msgpack5) {
buf = bench('buf = require("msgpack5")().encode(obj);', msgpack5.encode, data);
obj = bench('obj = require("msgpack5")().decode(buf);', msgpack5.decode, buf);
test(obj);
}
if (notepack) {
buf = bench('buf = require("notepack").encode(obj);', notepack.encode, data);
obj = bench('obj = require("notepack").decode(buf);', notepack.decode, buf);
test(obj);
}
if (msgpack_unpack) {
obj = bench('obj = require("msgpack-unpack").decode(buf);', msgpack_unpack, packed);
test(obj);
}
function JSON_stringify(src) {
return Buffer(JSON.stringify(src));
}
function msgpack_codec_pack(data) {
return Buffer(msgpack_codec.pack(data));
}
function bench(name, func, src) {
if (argv.length) {
var match = argv.filter(function(grep) {
return (name.indexOf(grep) > -1);
});
if (!match.length) return SKIP;
}
var ret, duration;
var start = new Date() - 0;
var count = 0;
while (1) {
var end = new Date() - 0;
duration = end - start;
if (duration >= limit) break;
while ((++count) % 100) ret = func(src);
}
name = rpad(name, COL1);
var score = Math.floor(count / duration * 1000);
count = lpad(count, COL2);
duration = lpad(duration, COL3);
score = lpad(score, COL4);
console.log(name, "|", count, "|", duration, "|", score);
return ret;
}
function rpad(str, len, chr) {
if (!chr) chr = " ";
while (str.length < len) str += chr;
return str;
}
function lpad(str, len, chr) {
if (!chr) chr = " ";
str += "";
while (str.length < len) str = chr + str;
return str;
}
function test(actual) {
if (actual === SKIP) return;
actual = JSON.stringify(actual);
if (actual === expected) return;
console.warn("expected: " + expected);
console.warn("actual: " + actual);
}
function SKIP() {
}
function try_require(name) {
try {
return require(name);
} catch (e) {
// ignore
}
}

10
node_modules/msgpack-lite/lib/browser.js generated vendored Normal file
View File

@@ -0,0 +1,10 @@
// browser.js
exports.encode = require("./encode").encode;
exports.decode = require("./decode").decode;
exports.Encoder = require("./encoder").Encoder;
exports.Decoder = require("./decoder").Decoder;
exports.createCodec = require("./ext").createCodec;
exports.codec = require("./codec").codec;

11
node_modules/msgpack-lite/lib/buffer-global.js generated vendored Normal file
View File

@@ -0,0 +1,11 @@
/* globals Buffer */
module.exports =
c(("undefined" !== typeof Buffer) && Buffer) ||
c(this.Buffer) ||
c(("undefined" !== typeof window) && window.Buffer) ||
this.Buffer;
function c(B) {
return B && B.isBuffer && B;
}

134
node_modules/msgpack-lite/lib/buffer-lite.js generated vendored Normal file
View File

@@ -0,0 +1,134 @@
// buffer-lite.js
var MAXBUFLEN = 8192;
exports.copy = copy;
exports.toString = toString;
exports.write = write;
/**
* Buffer.prototype.write()
*
* @param string {String}
* @param [offset] {Number}
* @returns {Number}
*/
function write(string, offset) {
var buffer = this;
var index = offset || (offset |= 0);
var length = string.length;
var chr = 0;
var i = 0;
while (i < length) {
chr = string.charCodeAt(i++);
if (chr < 128) {
buffer[index++] = chr;
} else if (chr < 0x800) {
// 2 bytes
buffer[index++] = 0xC0 | (chr >>> 6);
buffer[index++] = 0x80 | (chr & 0x3F);
} else if (chr < 0xD800 || chr > 0xDFFF) {
// 3 bytes
buffer[index++] = 0xE0 | (chr >>> 12);
buffer[index++] = 0x80 | ((chr >>> 6) & 0x3F);
buffer[index++] = 0x80 | (chr & 0x3F);
} else {
// 4 bytes - surrogate pair
chr = (((chr - 0xD800) << 10) | (string.charCodeAt(i++) - 0xDC00)) + 0x10000;
buffer[index++] = 0xF0 | (chr >>> 18);
buffer[index++] = 0x80 | ((chr >>> 12) & 0x3F);
buffer[index++] = 0x80 | ((chr >>> 6) & 0x3F);
buffer[index++] = 0x80 | (chr & 0x3F);
}
}
return index - offset;
}
/**
* Buffer.prototype.toString()
*
* @param [encoding] {String} ignored
* @param [start] {Number}
* @param [end] {Number}
* @returns {String}
*/
function toString(encoding, start, end) {
var buffer = this;
var index = start|0;
if (!end) end = buffer.length;
var string = '';
var chr = 0;
while (index < end) {
chr = buffer[index++];
if (chr < 128) {
string += String.fromCharCode(chr);
continue;
}
if ((chr & 0xE0) === 0xC0) {
// 2 bytes
chr = (chr & 0x1F) << 6 |
(buffer[index++] & 0x3F);
} else if ((chr & 0xF0) === 0xE0) {
// 3 bytes
chr = (chr & 0x0F) << 12 |
(buffer[index++] & 0x3F) << 6 |
(buffer[index++] & 0x3F);
} else if ((chr & 0xF8) === 0xF0) {
// 4 bytes
chr = (chr & 0x07) << 18 |
(buffer[index++] & 0x3F) << 12 |
(buffer[index++] & 0x3F) << 6 |
(buffer[index++] & 0x3F);
}
if (chr >= 0x010000) {
// A surrogate pair
chr -= 0x010000;
string += String.fromCharCode((chr >>> 10) + 0xD800, (chr & 0x3FF) + 0xDC00);
} else {
string += String.fromCharCode(chr);
}
}
return string;
}
/**
* Buffer.prototype.copy()
*
* @param target {Buffer}
* @param [targetStart] {Number}
* @param [start] {Number}
* @param [end] {Number}
* @returns {number}
*/
function copy(target, targetStart, start, end) {
var i;
if (!start) start = 0;
if (!end && end !== 0) end = this.length;
if (!targetStart) targetStart = 0;
var len = end - start;
if (target === this && start < targetStart && targetStart < end) {
// descending
for (i = len - 1; i >= 0; i--) {
target[i + targetStart] = this[i + start];
}
} else {
// ascending
for (i = 0; i < len; i++) {
target[i + targetStart] = this[i + start];
}
}
return len;
}

41
node_modules/msgpack-lite/lib/bufferish-array.js generated vendored Normal file
View File

@@ -0,0 +1,41 @@
// bufferish-array.js
var Bufferish = require("./bufferish");
var exports = module.exports = alloc(0);
exports.alloc = alloc;
exports.concat = Bufferish.concat;
exports.from = from;
/**
* @param size {Number}
* @returns {Buffer|Uint8Array|Array}
*/
function alloc(size) {
return new Array(size);
}
/**
* @param value {Array|ArrayBuffer|Buffer|String}
* @returns {Array}
*/
function from(value) {
if (!Bufferish.isBuffer(value) && Bufferish.isView(value)) {
// TypedArray to Uint8Array
value = Bufferish.Uint8Array.from(value);
} else if (Bufferish.isArrayBuffer(value)) {
// ArrayBuffer to Uint8Array
value = new Uint8Array(value);
} else if (typeof value === "string") {
// String to Array
return Bufferish.from.call(exports, value);
} else if (typeof value === "number") {
throw new TypeError('"value" argument must not be a number');
}
// Array-like to Array
return Array.prototype.slice.call(value);
}

46
node_modules/msgpack-lite/lib/bufferish-buffer.js generated vendored Normal file
View File

@@ -0,0 +1,46 @@
// bufferish-buffer.js
var Bufferish = require("./bufferish");
var Buffer = Bufferish.global;
var exports = module.exports = Bufferish.hasBuffer ? alloc(0) : [];
exports.alloc = Bufferish.hasBuffer && Buffer.alloc || alloc;
exports.concat = Bufferish.concat;
exports.from = from;
/**
* @param size {Number}
* @returns {Buffer|Uint8Array|Array}
*/
function alloc(size) {
return new Buffer(size);
}
/**
* @param value {Array|ArrayBuffer|Buffer|String}
* @returns {Buffer}
*/
function from(value) {
if (!Bufferish.isBuffer(value) && Bufferish.isView(value)) {
// TypedArray to Uint8Array
value = Bufferish.Uint8Array.from(value);
} else if (Bufferish.isArrayBuffer(value)) {
// ArrayBuffer to Uint8Array
value = new Uint8Array(value);
} else if (typeof value === "string") {
// String to Buffer
return Bufferish.from.call(exports, value);
} else if (typeof value === "number") {
throw new TypeError('"value" argument must not be a number');
}
// Array-like to Buffer
if (Buffer.from && Buffer.from.length !== 1) {
return Buffer.from(value); // node v6+
} else {
return new Buffer(value); // node v4
}
}

86
node_modules/msgpack-lite/lib/bufferish-proto.js generated vendored Normal file
View File

@@ -0,0 +1,86 @@
// bufferish-proto.js
/* jshint eqnull:true */
var BufferLite = require("./buffer-lite");
exports.copy = copy;
exports.slice = slice;
exports.toString = toString;
exports.write = gen("write");
var Bufferish = require("./bufferish");
var Buffer = Bufferish.global;
var isBufferShim = Bufferish.hasBuffer && ("TYPED_ARRAY_SUPPORT" in Buffer);
var brokenTypedArray = isBufferShim && !Buffer.TYPED_ARRAY_SUPPORT;
/**
* @param target {Buffer|Uint8Array|Array}
* @param [targetStart] {Number}
* @param [start] {Number}
* @param [end] {Number}
* @returns {Buffer|Uint8Array|Array}
*/
function copy(target, targetStart, start, end) {
var thisIsBuffer = Bufferish.isBuffer(this);
var targetIsBuffer = Bufferish.isBuffer(target);
if (thisIsBuffer && targetIsBuffer) {
// Buffer to Buffer
return this.copy(target, targetStart, start, end);
} else if (!brokenTypedArray && !thisIsBuffer && !targetIsBuffer &&
Bufferish.isView(this) && Bufferish.isView(target)) {
// Uint8Array to Uint8Array (except for minor some browsers)
var buffer = (start || end != null) ? slice.call(this, start, end) : this;
target.set(buffer, targetStart);
return buffer.length;
} else {
// other cases
return BufferLite.copy.call(this, target, targetStart, start, end);
}
}
/**
* @param [start] {Number}
* @param [end] {Number}
* @returns {Buffer|Uint8Array|Array}
*/
function slice(start, end) {
// for Buffer, Uint8Array (except for minor some browsers) and Array
var f = this.slice || (!brokenTypedArray && this.subarray);
if (f) return f.call(this, start, end);
// Uint8Array (for minor some browsers)
var target = Bufferish.alloc.call(this, end - start);
copy.call(this, target, 0, start, end);
return target;
}
/**
* Buffer.prototype.toString()
*
* @param [encoding] {String} ignored
* @param [start] {Number}
* @param [end] {Number}
* @returns {String}
*/
function toString(encoding, start, end) {
var f = (!isBufferShim && Bufferish.isBuffer(this)) ? this.toString : BufferLite.toString;
return f.apply(this, arguments);
}
/**
* @private
*/
function gen(method) {
return wrap;
function wrap() {
var f = this[method] || BufferLite[method];
return f.apply(this, arguments);
}
}

51
node_modules/msgpack-lite/lib/bufferish-uint8array.js generated vendored Normal file
View File

@@ -0,0 +1,51 @@
// bufferish-uint8array.js
var Bufferish = require("./bufferish");
var exports = module.exports = Bufferish.hasArrayBuffer ? alloc(0) : [];
exports.alloc = alloc;
exports.concat = Bufferish.concat;
exports.from = from;
/**
* @param size {Number}
* @returns {Buffer|Uint8Array|Array}
*/
function alloc(size) {
return new Uint8Array(size);
}
/**
* @param value {Array|ArrayBuffer|Buffer|String}
* @returns {Uint8Array}
*/
function from(value) {
if (Bufferish.isView(value)) {
// TypedArray to ArrayBuffer
var byteOffset = value.byteOffset;
var byteLength = value.byteLength;
value = value.buffer;
if (value.byteLength !== byteLength) {
if (value.slice) {
value = value.slice(byteOffset, byteOffset + byteLength);
} else {
// Android 4.1 does not have ArrayBuffer.prototype.slice
value = new Uint8Array(value);
if (value.byteLength !== byteLength) {
// TypedArray to ArrayBuffer to Uint8Array to Array
value = Array.prototype.slice.call(value, byteOffset, byteOffset + byteLength);
}
}
}
} else if (typeof value === "string") {
// String to Uint8Array
return Bufferish.from.call(exports, value);
} else if (typeof value === "number") {
throw new TypeError('"value" argument must not be a number');
}
return new Uint8Array(value);
}

108
node_modules/msgpack-lite/lib/bufferish.js generated vendored Normal file
View File

@@ -0,0 +1,108 @@
// bufferish.js
var Buffer = exports.global = require("./buffer-global");
var hasBuffer = exports.hasBuffer = Buffer && !!Buffer.isBuffer;
var hasArrayBuffer = exports.hasArrayBuffer = ("undefined" !== typeof ArrayBuffer);
var isArray = exports.isArray = require("isarray");
exports.isArrayBuffer = hasArrayBuffer ? isArrayBuffer : _false;
var isBuffer = exports.isBuffer = hasBuffer ? Buffer.isBuffer : _false;
var isView = exports.isView = hasArrayBuffer ? (ArrayBuffer.isView || _is("ArrayBuffer", "buffer")) : _false;
exports.alloc = alloc;
exports.concat = concat;
exports.from = from;
var BufferArray = exports.Array = require("./bufferish-array");
var BufferBuffer = exports.Buffer = require("./bufferish-buffer");
var BufferUint8Array = exports.Uint8Array = require("./bufferish-uint8array");
var BufferProto = exports.prototype = require("./bufferish-proto");
/**
* @param value {Array|ArrayBuffer|Buffer|String}
* @returns {Buffer|Uint8Array|Array}
*/
function from(value) {
if (typeof value === "string") {
return fromString.call(this, value);
} else {
return auto(this).from(value);
}
}
/**
* @param size {Number}
* @returns {Buffer|Uint8Array|Array}
*/
function alloc(size) {
return auto(this).alloc(size);
}
/**
* @param list {Array} array of (Buffer|Uint8Array|Array)s
* @param [length]
* @returns {Buffer|Uint8Array|Array}
*/
function concat(list, length) {
if (!length) {
length = 0;
Array.prototype.forEach.call(list, dryrun);
}
var ref = (this !== exports) && this || list[0];
var result = alloc.call(ref, length);
var offset = 0;
Array.prototype.forEach.call(list, append);
return result;
function dryrun(buffer) {
length += buffer.length;
}
function append(buffer) {
offset += BufferProto.copy.call(buffer, result, offset);
}
}
var _isArrayBuffer = _is("ArrayBuffer");
function isArrayBuffer(value) {
return (value instanceof ArrayBuffer) || _isArrayBuffer(value);
}
/**
* @private
*/
function fromString(value) {
var expected = value.length * 3;
var that = alloc.call(this, expected);
var actual = BufferProto.write.call(that, value);
if (expected !== actual) {
that = BufferProto.slice.call(that, 0, actual);
}
return that;
}
function auto(that) {
return isBuffer(that) ? BufferBuffer
: isView(that) ? BufferUint8Array
: isArray(that) ? BufferArray
: hasBuffer ? BufferBuffer
: hasArrayBuffer ? BufferUint8Array
: BufferArray;
}
function _false() {
return false;
}
function _is(name, key) {
/* jshint eqnull:true */
name = "[object " + name + "]";
return function(value) {
return (value != null) && {}.toString.call(key ? value[key] : value) === name;
};
}

97
node_modules/msgpack-lite/lib/cli.js generated vendored Normal file
View File

@@ -0,0 +1,97 @@
// cli.js
var fs = require("fs");
var Stream = require("stream");
var msgpack = require("../");
exports.CLI = CLI;
function help() {
var cfgmap = {
"M": "input MessagePack (default)",
"J": "input JSON",
"S": "input JSON(s) '\\n' separated stream",
"m": "output MessagePack (default)",
"j": "output JSON(s)",
"h": "show help message",
"1": "add a spacer for JSON output"
};
var keys = Object.keys(cfgmap);
var flags = keys.join("");
process.stderr.write("Usage: msgpack-lite [-" + flags + "] [infile] [outfile]\n");
keys.forEach(function(key) {
process.stderr.write(" -" + key + " " + cfgmap[key] + "\n");
});
process.exit(1);
}
function CLI() {
var input;
var pass = new Stream.PassThrough({objectMode: true});
var output;
var args = {};
Array.prototype.forEach.call(arguments, function(val) {
if (val[0] === "-") {
val.split("").forEach(function(c) {
args[c] = true;
});
} else if (!input) {
input = val;
} else {
output = val;
}
});
if (args.h) return help();
if (!Object.keys(args).length) return help();
if (input === "-") input = null;
if (output === "-") output = null;
input = input ? fs.createReadStream(input) : process.stdin;
output = output ? fs.createWriteStream(output) : process.stdout;
if (args.j) {
var spacer = args[2] ? " " : args[1] ? " " : null;
pass.on("data", function(data) {
output.write(JSON.stringify(data, null, spacer) + "\n");
});
} else {
// pass.pipe(msgpack.createEncodeStream()).pipe(output);
pass.on("data", function(data) {
output.write(msgpack.encode(data));
});
}
if (args.J || args.S) {
decodeJSON(input, pass, args);
} else {
input.pipe(msgpack.createDecodeStream()).pipe(pass);
}
}
function decodeJSON(input, output, args) {
var buf = "";
input.on("data", function(chunk) {
buf += chunk;
if (args.S) sendStreaming();
});
input.on("end", function() {
sendAll();
});
function sendAll() {
if (!buf.length) return;
output.write(JSON.parse(buf));
}
function sendStreaming(leave) {
var list = buf.split("\n");
buf = list.pop();
list.forEach(function(str) {
str = str.replace(/,\s*$/, "");
if (!str.length) return;
output.write(JSON.parse(str));
});
}
}

67
node_modules/msgpack-lite/lib/codec-base.js generated vendored Normal file
View File

@@ -0,0 +1,67 @@
// codec-base.js
var IS_ARRAY = require("isarray");
exports.createCodec = createCodec;
exports.install = install;
exports.filter = filter;
var Bufferish = require("./bufferish");
function Codec(options) {
if (!(this instanceof Codec)) return new Codec(options);
this.options = options;
this.init();
}
Codec.prototype.init = function() {
var options = this.options;
if (options && options.uint8array) {
this.bufferish = Bufferish.Uint8Array;
}
return this;
};
function install(props) {
for (var key in props) {
Codec.prototype[key] = add(Codec.prototype[key], props[key]);
}
}
function add(a, b) {
return (a && b) ? ab : (a || b);
function ab() {
a.apply(this, arguments);
return b.apply(this, arguments);
}
}
function join(filters) {
filters = filters.slice();
return function(value) {
return filters.reduce(iterator, value);
};
function iterator(value, filter) {
return filter(value);
}
}
function filter(filter) {
return IS_ARRAY(filter) ? join(filter) : filter;
}
// @public
// msgpack.createCodec()
function createCodec(options) {
return new Codec(options);
}
// default shared codec
exports.preset = createCodec({preset: true});

12
node_modules/msgpack-lite/lib/codec.js generated vendored Normal file
View File

@@ -0,0 +1,12 @@
// codec.js
// load both interfaces
require("./read-core");
require("./write-core");
// @public
// msgpack.codec.preset
exports.codec = {
preset: require("./codec-base").preset
};

27
node_modules/msgpack-lite/lib/decode-buffer.js generated vendored Normal file
View File

@@ -0,0 +1,27 @@
// decode-buffer.js
exports.DecodeBuffer = DecodeBuffer;
var preset = require("./read-core").preset;
var FlexDecoder = require("./flex-buffer").FlexDecoder;
FlexDecoder.mixin(DecodeBuffer.prototype);
function DecodeBuffer(options) {
if (!(this instanceof DecodeBuffer)) return new DecodeBuffer(options);
if (options) {
this.options = options;
if (options.codec) {
var codec = this.codec = options.codec;
if (codec.bufferish) this.bufferish = codec.bufferish;
}
}
}
DecodeBuffer.prototype.codec = preset;
DecodeBuffer.prototype.fetch = function() {
return this.codec.decode(this);
};

32
node_modules/msgpack-lite/lib/decode-stream.js generated vendored Normal file
View File

@@ -0,0 +1,32 @@
// decode-stream.js
exports.createDecodeStream = DecodeStream;
var util = require("util");
var Transform = require("stream").Transform;
var DecodeBuffer = require("./decode-buffer").DecodeBuffer;
util.inherits(DecodeStream, Transform);
var DEFAULT_OPTIONS = {objectMode: true};
function DecodeStream(options) {
if (!(this instanceof DecodeStream)) return new DecodeStream(options);
if (options) {
options.objectMode = true;
} else {
options = DEFAULT_OPTIONS;
}
Transform.call(this, options);
var stream = this;
var decoder = this.decoder = new DecodeBuffer(options);
decoder.push = function(chunk) {
stream.push(chunk);
};
}
DecodeStream.prototype._transform = function(chunk, encoding, callback) {
this.decoder.write(chunk);
this.decoder.flush();
if (callback) callback();
};

11
node_modules/msgpack-lite/lib/decode.js generated vendored Normal file
View File

@@ -0,0 +1,11 @@
// decode.js
exports.decode = decode;
var DecodeBuffer = require("./decode-buffer").DecodeBuffer;
function decode(input, options) {
var decoder = new DecodeBuffer(options);
decoder.write(input);
return decoder.read();
}

29
node_modules/msgpack-lite/lib/decoder.js generated vendored Normal file
View File

@@ -0,0 +1,29 @@
// decoder.js
exports.Decoder = Decoder;
var EventLite = require("event-lite");
var DecodeBuffer = require("./decode-buffer").DecodeBuffer;
function Decoder(options) {
if (!(this instanceof Decoder)) return new Decoder(options);
DecodeBuffer.call(this, options);
}
Decoder.prototype = new DecodeBuffer();
EventLite.mixin(Decoder.prototype);
Decoder.prototype.decode = function(chunk) {
if (arguments.length) this.write(chunk);
this.flush();
};
Decoder.prototype.push = function(chunk) {
this.emit("data", chunk);
};
Decoder.prototype.end = function(chunk) {
this.decode(chunk);
this.emit("end");
};

27
node_modules/msgpack-lite/lib/encode-buffer.js generated vendored Normal file
View File

@@ -0,0 +1,27 @@
// encode-buffer.js
exports.EncodeBuffer = EncodeBuffer;
var preset = require("./write-core").preset;
var FlexEncoder = require("./flex-buffer").FlexEncoder;
FlexEncoder.mixin(EncodeBuffer.prototype);
function EncodeBuffer(options) {
if (!(this instanceof EncodeBuffer)) return new EncodeBuffer(options);
if (options) {
this.options = options;
if (options.codec) {
var codec = this.codec = options.codec;
if (codec.bufferish) this.bufferish = codec.bufferish;
}
}
}
EncodeBuffer.prototype.codec = preset;
EncodeBuffer.prototype.write = function(input) {
this.codec.encode(this, input);
};

37
node_modules/msgpack-lite/lib/encode-stream.js generated vendored Normal file
View File

@@ -0,0 +1,37 @@
// encode-stream.js
exports.createEncodeStream = EncodeStream;
var util = require("util");
var Transform = require("stream").Transform;
var EncodeBuffer = require("./encode-buffer").EncodeBuffer;
util.inherits(EncodeStream, Transform);
var DEFAULT_OPTIONS = {objectMode: true};
function EncodeStream(options) {
if (!(this instanceof EncodeStream)) return new EncodeStream(options);
if (options) {
options.objectMode = true;
} else {
options = DEFAULT_OPTIONS;
}
Transform.call(this, options);
var stream = this;
var encoder = this.encoder = new EncodeBuffer(options);
encoder.push = function(chunk) {
stream.push(chunk);
};
}
EncodeStream.prototype._transform = function(chunk, encoding, callback) {
this.encoder.write(chunk);
if (callback) callback();
};
EncodeStream.prototype._flush = function(callback) {
this.encoder.flush();
if (callback) callback();
};

11
node_modules/msgpack-lite/lib/encode.js generated vendored Normal file
View File

@@ -0,0 +1,11 @@
// encode.js
exports.encode = encode;
var EncodeBuffer = require("./encode-buffer").EncodeBuffer;
function encode(input, options) {
var encoder = new EncodeBuffer(options);
encoder.write(input);
return encoder.read();
}

26
node_modules/msgpack-lite/lib/encoder.js generated vendored Normal file
View File

@@ -0,0 +1,26 @@
// encoder.js
exports.Encoder = Encoder;
var EventLite = require("event-lite");
var EncodeBuffer = require("./encode-buffer").EncodeBuffer;
function Encoder(options) {
if (!(this instanceof Encoder)) return new Encoder(options);
EncodeBuffer.call(this, options);
}
Encoder.prototype = new EncodeBuffer();
EventLite.mixin(Encoder.prototype);
Encoder.prototype.encode = function(chunk) {
this.write(chunk);
this.emit("data", this.read());
};
Encoder.prototype.end = function(chunk) {
if (arguments.length) this.encode(chunk);
this.flush();
this.emit("end");
};

11
node_modules/msgpack-lite/lib/ext-buffer.js generated vendored Normal file
View File

@@ -0,0 +1,11 @@
// ext-buffer.js
exports.ExtBuffer = ExtBuffer;
var Bufferish = require("./bufferish");
function ExtBuffer(buffer, type) {
if (!(this instanceof ExtBuffer)) return new ExtBuffer(buffer, type);
this.buffer = Bufferish.from(buffer);
this.type = type;
}

78
node_modules/msgpack-lite/lib/ext-packer.js generated vendored Normal file
View File

@@ -0,0 +1,78 @@
// ext-packer.js
exports.setExtPackers = setExtPackers;
var Bufferish = require("./bufferish");
var Buffer = Bufferish.global;
var packTypedArray = Bufferish.Uint8Array.from;
var _encode;
var ERROR_COLUMNS = {name: 1, message: 1, stack: 1, columnNumber: 1, fileName: 1, lineNumber: 1};
function setExtPackers(codec) {
codec.addExtPacker(0x0E, Error, [packError, encode]);
codec.addExtPacker(0x01, EvalError, [packError, encode]);
codec.addExtPacker(0x02, RangeError, [packError, encode]);
codec.addExtPacker(0x03, ReferenceError, [packError, encode]);
codec.addExtPacker(0x04, SyntaxError, [packError, encode]);
codec.addExtPacker(0x05, TypeError, [packError, encode]);
codec.addExtPacker(0x06, URIError, [packError, encode]);
codec.addExtPacker(0x0A, RegExp, [packRegExp, encode]);
codec.addExtPacker(0x0B, Boolean, [packValueOf, encode]);
codec.addExtPacker(0x0C, String, [packValueOf, encode]);
codec.addExtPacker(0x0D, Date, [Number, encode]);
codec.addExtPacker(0x0F, Number, [packValueOf, encode]);
if ("undefined" !== typeof Uint8Array) {
codec.addExtPacker(0x11, Int8Array, packTypedArray);
codec.addExtPacker(0x12, Uint8Array, packTypedArray);
codec.addExtPacker(0x13, Int16Array, packTypedArray);
codec.addExtPacker(0x14, Uint16Array, packTypedArray);
codec.addExtPacker(0x15, Int32Array, packTypedArray);
codec.addExtPacker(0x16, Uint32Array, packTypedArray);
codec.addExtPacker(0x17, Float32Array, packTypedArray);
// PhantomJS/1.9.7 doesn't have Float64Array
if ("undefined" !== typeof Float64Array) {
codec.addExtPacker(0x18, Float64Array, packTypedArray);
}
// IE10 doesn't have Uint8ClampedArray
if ("undefined" !== typeof Uint8ClampedArray) {
codec.addExtPacker(0x19, Uint8ClampedArray, packTypedArray);
}
codec.addExtPacker(0x1A, ArrayBuffer, packTypedArray);
codec.addExtPacker(0x1D, DataView, packTypedArray);
}
if (Bufferish.hasBuffer) {
codec.addExtPacker(0x1B, Buffer, Bufferish.from);
}
}
function encode(input) {
if (!_encode) _encode = require("./encode").encode; // lazy load
return _encode(input);
}
function packValueOf(value) {
return (value).valueOf();
}
function packRegExp(value) {
value = RegExp.prototype.toString.call(value).split("/");
value.shift();
var out = [value.pop()];
out.unshift(value.join("/"));
return out;
}
function packError(value) {
var out = {};
for (var key in ERROR_COLUMNS) {
out[key] = value[key];
}
return out;
}

81
node_modules/msgpack-lite/lib/ext-unpacker.js generated vendored Normal file
View File

@@ -0,0 +1,81 @@
// ext-unpacker.js
exports.setExtUnpackers = setExtUnpackers;
var Bufferish = require("./bufferish");
var Buffer = Bufferish.global;
var _decode;
var ERROR_COLUMNS = {name: 1, message: 1, stack: 1, columnNumber: 1, fileName: 1, lineNumber: 1};
function setExtUnpackers(codec) {
codec.addExtUnpacker(0x0E, [decode, unpackError(Error)]);
codec.addExtUnpacker(0x01, [decode, unpackError(EvalError)]);
codec.addExtUnpacker(0x02, [decode, unpackError(RangeError)]);
codec.addExtUnpacker(0x03, [decode, unpackError(ReferenceError)]);
codec.addExtUnpacker(0x04, [decode, unpackError(SyntaxError)]);
codec.addExtUnpacker(0x05, [decode, unpackError(TypeError)]);
codec.addExtUnpacker(0x06, [decode, unpackError(URIError)]);
codec.addExtUnpacker(0x0A, [decode, unpackRegExp]);
codec.addExtUnpacker(0x0B, [decode, unpackClass(Boolean)]);
codec.addExtUnpacker(0x0C, [decode, unpackClass(String)]);
codec.addExtUnpacker(0x0D, [decode, unpackClass(Date)]);
codec.addExtUnpacker(0x0F, [decode, unpackClass(Number)]);
if ("undefined" !== typeof Uint8Array) {
codec.addExtUnpacker(0x11, unpackClass(Int8Array));
codec.addExtUnpacker(0x12, unpackClass(Uint8Array));
codec.addExtUnpacker(0x13, [unpackArrayBuffer, unpackClass(Int16Array)]);
codec.addExtUnpacker(0x14, [unpackArrayBuffer, unpackClass(Uint16Array)]);
codec.addExtUnpacker(0x15, [unpackArrayBuffer, unpackClass(Int32Array)]);
codec.addExtUnpacker(0x16, [unpackArrayBuffer, unpackClass(Uint32Array)]);
codec.addExtUnpacker(0x17, [unpackArrayBuffer, unpackClass(Float32Array)]);
// PhantomJS/1.9.7 doesn't have Float64Array
if ("undefined" !== typeof Float64Array) {
codec.addExtUnpacker(0x18, [unpackArrayBuffer, unpackClass(Float64Array)]);
}
// IE10 doesn't have Uint8ClampedArray
if ("undefined" !== typeof Uint8ClampedArray) {
codec.addExtUnpacker(0x19, unpackClass(Uint8ClampedArray));
}
codec.addExtUnpacker(0x1A, unpackArrayBuffer);
codec.addExtUnpacker(0x1D, [unpackArrayBuffer, unpackClass(DataView)]);
}
if (Bufferish.hasBuffer) {
codec.addExtUnpacker(0x1B, unpackClass(Buffer));
}
}
function decode(input) {
if (!_decode) _decode = require("./decode").decode; // lazy load
return _decode(input);
}
function unpackRegExp(value) {
return RegExp.apply(null, value);
}
function unpackError(Class) {
return function(value) {
var out = new Class();
for (var key in ERROR_COLUMNS) {
out[key] = value[key];
}
return out;
};
}
function unpackClass(Class) {
return function(value) {
return new Class(value);
};
}
function unpackArrayBuffer(value) {
return (new Uint8Array(value)).buffer;
}

7
node_modules/msgpack-lite/lib/ext.js generated vendored Normal file
View File

@@ -0,0 +1,7 @@
// ext.js
// load both interfaces
require("./read-core");
require("./write-core");
exports.createCodec = require("./codec-base").createCodec;

194
node_modules/msgpack-lite/lib/flex-buffer.js generated vendored Normal file
View File

@@ -0,0 +1,194 @@
// flex-buffer.js
exports.FlexDecoder = FlexDecoder;
exports.FlexEncoder = FlexEncoder;
var Bufferish = require("./bufferish");
var MIN_BUFFER_SIZE = 2048;
var MAX_BUFFER_SIZE = 65536;
var BUFFER_SHORTAGE = "BUFFER_SHORTAGE";
function FlexDecoder() {
if (!(this instanceof FlexDecoder)) return new FlexDecoder();
}
function FlexEncoder() {
if (!(this instanceof FlexEncoder)) return new FlexEncoder();
}
FlexDecoder.mixin = mixinFactory(getDecoderMethods());
FlexDecoder.mixin(FlexDecoder.prototype);
FlexEncoder.mixin = mixinFactory(getEncoderMethods());
FlexEncoder.mixin(FlexEncoder.prototype);
function getDecoderMethods() {
return {
bufferish: Bufferish,
write: write,
fetch: fetch,
flush: flush,
push: push,
pull: pull,
read: read,
reserve: reserve,
offset: 0
};
function write(chunk) {
var prev = this.offset ? Bufferish.prototype.slice.call(this.buffer, this.offset) : this.buffer;
this.buffer = prev ? (chunk ? this.bufferish.concat([prev, chunk]) : prev) : chunk;
this.offset = 0;
}
function flush() {
while (this.offset < this.buffer.length) {
var start = this.offset;
var value;
try {
value = this.fetch();
} catch (e) {
if (e && e.message != BUFFER_SHORTAGE) throw e;
// rollback
this.offset = start;
break;
}
this.push(value);
}
}
function reserve(length) {
var start = this.offset;
var end = start + length;
if (end > this.buffer.length) throw new Error(BUFFER_SHORTAGE);
this.offset = end;
return start;
}
}
function getEncoderMethods() {
return {
bufferish: Bufferish,
write: write,
fetch: fetch,
flush: flush,
push: push,
pull: pull,
read: read,
reserve: reserve,
send: send,
maxBufferSize: MAX_BUFFER_SIZE,
minBufferSize: MIN_BUFFER_SIZE,
offset: 0,
start: 0
};
function fetch() {
var start = this.start;
if (start < this.offset) {
var end = this.start = this.offset;
return Bufferish.prototype.slice.call(this.buffer, start, end);
}
}
function flush() {
while (this.start < this.offset) {
var value = this.fetch();
if (value) this.push(value);
}
}
function pull() {
var buffers = this.buffers || (this.buffers = []);
var chunk = buffers.length > 1 ? this.bufferish.concat(buffers) : buffers[0];
buffers.length = 0; // buffer exhausted
return chunk;
}
function reserve(length) {
var req = length | 0;
if (this.buffer) {
var size = this.buffer.length;
var start = this.offset | 0;
var end = start + req;
// is it long enough?
if (end < size) {
this.offset = end;
return start;
}
// flush current buffer
this.flush();
// resize it to 2x current length
length = Math.max(length, Math.min(size * 2, this.maxBufferSize));
}
// minimum buffer size
length = Math.max(length, this.minBufferSize);
// allocate new buffer
this.buffer = this.bufferish.alloc(length);
this.start = 0;
this.offset = req;
return 0;
}
function send(buffer) {
var length = buffer.length;
if (length > this.minBufferSize) {
this.flush();
this.push(buffer);
} else {
var offset = this.reserve(length);
Bufferish.prototype.copy.call(buffer, this.buffer, offset);
}
}
}
// common methods
function write() {
throw new Error("method not implemented: write()");
}
function fetch() {
throw new Error("method not implemented: fetch()");
}
function read() {
var length = this.buffers && this.buffers.length;
// fetch the first result
if (!length) return this.fetch();
// flush current buffer
this.flush();
// read from the results
return this.pull();
}
function push(chunk) {
var buffers = this.buffers || (this.buffers = []);
buffers.push(chunk);
}
function pull() {
var buffers = this.buffers || (this.buffers = []);
return buffers.shift();
}
function mixinFactory(source) {
return mixin;
function mixin(target) {
for (var key in source) {
target[key] = source[key];
}
return target;
}
}

52
node_modules/msgpack-lite/lib/read-core.js generated vendored Normal file
View File

@@ -0,0 +1,52 @@
// read-core.js
var ExtBuffer = require("./ext-buffer").ExtBuffer;
var ExtUnpacker = require("./ext-unpacker");
var readUint8 = require("./read-format").readUint8;
var ReadToken = require("./read-token");
var CodecBase = require("./codec-base");
CodecBase.install({
addExtUnpacker: addExtUnpacker,
getExtUnpacker: getExtUnpacker,
init: init
});
exports.preset = init.call(CodecBase.preset);
function getDecoder(options) {
var readToken = ReadToken.getReadToken(options);
return decode;
function decode(decoder) {
var type = readUint8(decoder);
var func = readToken[type];
if (!func) throw new Error("Invalid type: " + (type ? ("0x" + type.toString(16)) : type));
return func(decoder);
}
}
function init() {
var options = this.options;
this.decode = getDecoder(options);
if (options && options.preset) {
ExtUnpacker.setExtUnpackers(this);
}
return this;
}
function addExtUnpacker(etype, unpacker) {
var unpackers = this.extUnpackers || (this.extUnpackers = []);
unpackers[etype] = CodecBase.filter(unpacker);
}
function getExtUnpacker(type) {
var unpackers = this.extUnpackers || (this.extUnpackers = []);
return unpackers[type] || extUnpacker;
function extUnpacker(buffer) {
return new ExtBuffer(buffer, type);
}
}

181
node_modules/msgpack-lite/lib/read-format.js generated vendored Normal file
View File

@@ -0,0 +1,181 @@
// read-format.js
var ieee754 = require("ieee754");
var Int64Buffer = require("int64-buffer");
var Uint64BE = Int64Buffer.Uint64BE;
var Int64BE = Int64Buffer.Int64BE;
exports.getReadFormat = getReadFormat;
exports.readUint8 = uint8;
var Bufferish = require("./bufferish");
var BufferProto = require("./bufferish-proto");
var HAS_MAP = ("undefined" !== typeof Map);
var NO_ASSERT = true;
function getReadFormat(options) {
var binarraybuffer = Bufferish.hasArrayBuffer && options && options.binarraybuffer;
var int64 = options && options.int64;
var usemap = HAS_MAP && options && options.usemap;
var readFormat = {
map: (usemap ? map_to_map : map_to_obj),
array: array,
str: str,
bin: (binarraybuffer ? bin_arraybuffer : bin_buffer),
ext: ext,
uint8: uint8,
uint16: uint16,
uint32: uint32,
uint64: read(8, int64 ? readUInt64BE_int64 : readUInt64BE),
int8: int8,
int16: int16,
int32: int32,
int64: read(8, int64 ? readInt64BE_int64 : readInt64BE),
float32: read(4, readFloatBE),
float64: read(8, readDoubleBE)
};
return readFormat;
}
function map_to_obj(decoder, len) {
var value = {};
var i;
var k = new Array(len);
var v = new Array(len);
var decode = decoder.codec.decode;
for (i = 0; i < len; i++) {
k[i] = decode(decoder);
v[i] = decode(decoder);
}
for (i = 0; i < len; i++) {
value[k[i]] = v[i];
}
return value;
}
function map_to_map(decoder, len) {
var value = new Map();
var i;
var k = new Array(len);
var v = new Array(len);
var decode = decoder.codec.decode;
for (i = 0; i < len; i++) {
k[i] = decode(decoder);
v[i] = decode(decoder);
}
for (i = 0; i < len; i++) {
value.set(k[i], v[i]);
}
return value;
}
function array(decoder, len) {
var value = new Array(len);
var decode = decoder.codec.decode;
for (var i = 0; i < len; i++) {
value[i] = decode(decoder);
}
return value;
}
function str(decoder, len) {
var start = decoder.reserve(len);
var end = start + len;
return BufferProto.toString.call(decoder.buffer, "utf-8", start, end);
}
function bin_buffer(decoder, len) {
var start = decoder.reserve(len);
var end = start + len;
var buf = BufferProto.slice.call(decoder.buffer, start, end);
return Bufferish.from(buf);
}
function bin_arraybuffer(decoder, len) {
var start = decoder.reserve(len);
var end = start + len;
var buf = BufferProto.slice.call(decoder.buffer, start, end);
return Bufferish.Uint8Array.from(buf).buffer;
}
function ext(decoder, len) {
var start = decoder.reserve(len+1);
var type = decoder.buffer[start++];
var end = start + len;
var unpack = decoder.codec.getExtUnpacker(type);
if (!unpack) throw new Error("Invalid ext type: " + (type ? ("0x" + type.toString(16)) : type));
var buf = BufferProto.slice.call(decoder.buffer, start, end);
return unpack(buf);
}
function uint8(decoder) {
var start = decoder.reserve(1);
return decoder.buffer[start];
}
function int8(decoder) {
var start = decoder.reserve(1);
var value = decoder.buffer[start];
return (value & 0x80) ? value - 0x100 : value;
}
function uint16(decoder) {
var start = decoder.reserve(2);
var buffer = decoder.buffer;
return (buffer[start++] << 8) | buffer[start];
}
function int16(decoder) {
var start = decoder.reserve(2);
var buffer = decoder.buffer;
var value = (buffer[start++] << 8) | buffer[start];
return (value & 0x8000) ? value - 0x10000 : value;
}
function uint32(decoder) {
var start = decoder.reserve(4);
var buffer = decoder.buffer;
return (buffer[start++] * 16777216) + (buffer[start++] << 16) + (buffer[start++] << 8) + buffer[start];
}
function int32(decoder) {
var start = decoder.reserve(4);
var buffer = decoder.buffer;
return (buffer[start++] << 24) | (buffer[start++] << 16) | (buffer[start++] << 8) | buffer[start];
}
function read(len, method) {
return function(decoder) {
var start = decoder.reserve(len);
return method.call(decoder.buffer, start, NO_ASSERT);
};
}
function readUInt64BE(start) {
return new Uint64BE(this, start).toNumber();
}
function readInt64BE(start) {
return new Int64BE(this, start).toNumber();
}
function readUInt64BE_int64(start) {
return new Uint64BE(this, start);
}
function readInt64BE_int64(start) {
return new Int64BE(this, start);
}
function readFloatBE(start) {
return ieee754.read(this, start, false, 23, 4);
}
function readDoubleBE(start) {
return ieee754.read(this, start, false, 52, 8);
}

161
node_modules/msgpack-lite/lib/read-token.js generated vendored Normal file
View File

@@ -0,0 +1,161 @@
// read-token.js
var ReadFormat = require("./read-format");
exports.getReadToken = getReadToken;
function getReadToken(options) {
var format = ReadFormat.getReadFormat(options);
if (options && options.useraw) {
return init_useraw(format);
} else {
return init_token(format);
}
}
function init_token(format) {
var i;
var token = new Array(256);
// positive fixint -- 0x00 - 0x7f
for (i = 0x00; i <= 0x7f; i++) {
token[i] = constant(i);
}
// fixmap -- 0x80 - 0x8f
for (i = 0x80; i <= 0x8f; i++) {
token[i] = fix(i - 0x80, format.map);
}
// fixarray -- 0x90 - 0x9f
for (i = 0x90; i <= 0x9f; i++) {
token[i] = fix(i - 0x90, format.array);
}
// fixstr -- 0xa0 - 0xbf
for (i = 0xa0; i <= 0xbf; i++) {
token[i] = fix(i - 0xa0, format.str);
}
// nil -- 0xc0
token[0xc0] = constant(null);
// (never used) -- 0xc1
token[0xc1] = null;
// false -- 0xc2
// true -- 0xc3
token[0xc2] = constant(false);
token[0xc3] = constant(true);
// bin 8 -- 0xc4
// bin 16 -- 0xc5
// bin 32 -- 0xc6
token[0xc4] = flex(format.uint8, format.bin);
token[0xc5] = flex(format.uint16, format.bin);
token[0xc6] = flex(format.uint32, format.bin);
// ext 8 -- 0xc7
// ext 16 -- 0xc8
// ext 32 -- 0xc9
token[0xc7] = flex(format.uint8, format.ext);
token[0xc8] = flex(format.uint16, format.ext);
token[0xc9] = flex(format.uint32, format.ext);
// float 32 -- 0xca
// float 64 -- 0xcb
token[0xca] = format.float32;
token[0xcb] = format.float64;
// uint 8 -- 0xcc
// uint 16 -- 0xcd
// uint 32 -- 0xce
// uint 64 -- 0xcf
token[0xcc] = format.uint8;
token[0xcd] = format.uint16;
token[0xce] = format.uint32;
token[0xcf] = format.uint64;
// int 8 -- 0xd0
// int 16 -- 0xd1
// int 32 -- 0xd2
// int 64 -- 0xd3
token[0xd0] = format.int8;
token[0xd1] = format.int16;
token[0xd2] = format.int32;
token[0xd3] = format.int64;
// fixext 1 -- 0xd4
// fixext 2 -- 0xd5
// fixext 4 -- 0xd6
// fixext 8 -- 0xd7
// fixext 16 -- 0xd8
token[0xd4] = fix(1, format.ext);
token[0xd5] = fix(2, format.ext);
token[0xd6] = fix(4, format.ext);
token[0xd7] = fix(8, format.ext);
token[0xd8] = fix(16, format.ext);
// str 8 -- 0xd9
// str 16 -- 0xda
// str 32 -- 0xdb
token[0xd9] = flex(format.uint8, format.str);
token[0xda] = flex(format.uint16, format.str);
token[0xdb] = flex(format.uint32, format.str);
// array 16 -- 0xdc
// array 32 -- 0xdd
token[0xdc] = flex(format.uint16, format.array);
token[0xdd] = flex(format.uint32, format.array);
// map 16 -- 0xde
// map 32 -- 0xdf
token[0xde] = flex(format.uint16, format.map);
token[0xdf] = flex(format.uint32, format.map);
// negative fixint -- 0xe0 - 0xff
for (i = 0xe0; i <= 0xff; i++) {
token[i] = constant(i - 0x100);
}
return token;
}
function init_useraw(format) {
var i;
var token = init_token(format).slice();
// raw 8 -- 0xd9
// raw 16 -- 0xda
// raw 32 -- 0xdb
token[0xd9] = token[0xc4];
token[0xda] = token[0xc5];
token[0xdb] = token[0xc6];
// fixraw -- 0xa0 - 0xbf
for (i = 0xa0; i <= 0xbf; i++) {
token[i] = fix(i - 0xa0, format.bin);
}
return token;
}
function constant(value) {
return function() {
return value;
};
}
function flex(lenFunc, decodeFunc) {
return function(decoder) {
var len = lenFunc(decoder);
return decodeFunc(decoder, len);
};
}
function fix(len, method) {
return function(decoder) {
return method(decoder, len);
};
}

69
node_modules/msgpack-lite/lib/write-core.js generated vendored Normal file
View File

@@ -0,0 +1,69 @@
// write-core.js
var ExtBuffer = require("./ext-buffer").ExtBuffer;
var ExtPacker = require("./ext-packer");
var WriteType = require("./write-type");
var CodecBase = require("./codec-base");
CodecBase.install({
addExtPacker: addExtPacker,
getExtPacker: getExtPacker,
init: init
});
exports.preset = init.call(CodecBase.preset);
function getEncoder(options) {
var writeType = WriteType.getWriteType(options);
return encode;
function encode(encoder, value) {
var func = writeType[typeof value];
if (!func) throw new Error("Unsupported type \"" + (typeof value) + "\": " + value);
func(encoder, value);
}
}
function init() {
var options = this.options;
this.encode = getEncoder(options);
if (options && options.preset) {
ExtPacker.setExtPackers(this);
}
return this;
}
function addExtPacker(etype, Class, packer) {
packer = CodecBase.filter(packer);
var name = Class.name;
if (name && name !== "Object") {
var packers = this.extPackers || (this.extPackers = {});
packers[name] = extPacker;
} else {
// fallback for IE
var list = this.extEncoderList || (this.extEncoderList = []);
list.unshift([Class, extPacker]);
}
function extPacker(value) {
if (packer) value = packer(value);
return new ExtBuffer(value, etype);
}
}
function getExtPacker(value) {
var packers = this.extPackers || (this.extPackers = {});
var c = value.constructor;
var e = c && c.name && packers[c.name];
if (e) return e;
// fallback for IE
var list = this.extEncoderList || (this.extEncoderList = []);
var len = list.length;
for (var i = 0; i < len; i++) {
var pair = list[i];
if (c === pair[0]) return pair[1];
}
}

227
node_modules/msgpack-lite/lib/write-token.js generated vendored Normal file
View File

@@ -0,0 +1,227 @@
// write-token.js
var ieee754 = require("ieee754");
var Int64Buffer = require("int64-buffer");
var Uint64BE = Int64Buffer.Uint64BE;
var Int64BE = Int64Buffer.Int64BE;
var uint8 = require("./write-uint8").uint8;
var Bufferish = require("./bufferish");
var Buffer = Bufferish.global;
var IS_BUFFER_SHIM = Bufferish.hasBuffer && ("TYPED_ARRAY_SUPPORT" in Buffer);
var NO_TYPED_ARRAY = IS_BUFFER_SHIM && !Buffer.TYPED_ARRAY_SUPPORT;
var Buffer_prototype = Bufferish.hasBuffer && Buffer.prototype || {};
exports.getWriteToken = getWriteToken;
function getWriteToken(options) {
if (options && options.uint8array) {
return init_uint8array();
} else if (NO_TYPED_ARRAY || (Bufferish.hasBuffer && options && options.safe)) {
return init_safe();
} else {
return init_token();
}
}
function init_uint8array() {
var token = init_token();
// float 32 -- 0xca
// float 64 -- 0xcb
token[0xca] = writeN(0xca, 4, writeFloatBE);
token[0xcb] = writeN(0xcb, 8, writeDoubleBE);
return token;
}
// Node.js and browsers with TypedArray
function init_token() {
// (immediate values)
// positive fixint -- 0x00 - 0x7f
// nil -- 0xc0
// false -- 0xc2
// true -- 0xc3
// negative fixint -- 0xe0 - 0xff
var token = uint8.slice();
// bin 8 -- 0xc4
// bin 16 -- 0xc5
// bin 32 -- 0xc6
token[0xc4] = write1(0xc4);
token[0xc5] = write2(0xc5);
token[0xc6] = write4(0xc6);
// ext 8 -- 0xc7
// ext 16 -- 0xc8
// ext 32 -- 0xc9
token[0xc7] = write1(0xc7);
token[0xc8] = write2(0xc8);
token[0xc9] = write4(0xc9);
// float 32 -- 0xca
// float 64 -- 0xcb
token[0xca] = writeN(0xca, 4, (Buffer_prototype.writeFloatBE || writeFloatBE), true);
token[0xcb] = writeN(0xcb, 8, (Buffer_prototype.writeDoubleBE || writeDoubleBE), true);
// uint 8 -- 0xcc
// uint 16 -- 0xcd
// uint 32 -- 0xce
// uint 64 -- 0xcf
token[0xcc] = write1(0xcc);
token[0xcd] = write2(0xcd);
token[0xce] = write4(0xce);
token[0xcf] = writeN(0xcf, 8, writeUInt64BE);
// int 8 -- 0xd0
// int 16 -- 0xd1
// int 32 -- 0xd2
// int 64 -- 0xd3
token[0xd0] = write1(0xd0);
token[0xd1] = write2(0xd1);
token[0xd2] = write4(0xd2);
token[0xd3] = writeN(0xd3, 8, writeInt64BE);
// str 8 -- 0xd9
// str 16 -- 0xda
// str 32 -- 0xdb
token[0xd9] = write1(0xd9);
token[0xda] = write2(0xda);
token[0xdb] = write4(0xdb);
// array 16 -- 0xdc
// array 32 -- 0xdd
token[0xdc] = write2(0xdc);
token[0xdd] = write4(0xdd);
// map 16 -- 0xde
// map 32 -- 0xdf
token[0xde] = write2(0xde);
token[0xdf] = write4(0xdf);
return token;
}
// safe mode: for old browsers and who needs asserts
function init_safe() {
// (immediate values)
// positive fixint -- 0x00 - 0x7f
// nil -- 0xc0
// false -- 0xc2
// true -- 0xc3
// negative fixint -- 0xe0 - 0xff
var token = uint8.slice();
// bin 8 -- 0xc4
// bin 16 -- 0xc5
// bin 32 -- 0xc6
token[0xc4] = writeN(0xc4, 1, Buffer.prototype.writeUInt8);
token[0xc5] = writeN(0xc5, 2, Buffer.prototype.writeUInt16BE);
token[0xc6] = writeN(0xc6, 4, Buffer.prototype.writeUInt32BE);
// ext 8 -- 0xc7
// ext 16 -- 0xc8
// ext 32 -- 0xc9
token[0xc7] = writeN(0xc7, 1, Buffer.prototype.writeUInt8);
token[0xc8] = writeN(0xc8, 2, Buffer.prototype.writeUInt16BE);
token[0xc9] = writeN(0xc9, 4, Buffer.prototype.writeUInt32BE);
// float 32 -- 0xca
// float 64 -- 0xcb
token[0xca] = writeN(0xca, 4, Buffer.prototype.writeFloatBE);
token[0xcb] = writeN(0xcb, 8, Buffer.prototype.writeDoubleBE);
// uint 8 -- 0xcc
// uint 16 -- 0xcd
// uint 32 -- 0xce
// uint 64 -- 0xcf
token[0xcc] = writeN(0xcc, 1, Buffer.prototype.writeUInt8);
token[0xcd] = writeN(0xcd, 2, Buffer.prototype.writeUInt16BE);
token[0xce] = writeN(0xce, 4, Buffer.prototype.writeUInt32BE);
token[0xcf] = writeN(0xcf, 8, writeUInt64BE);
// int 8 -- 0xd0
// int 16 -- 0xd1
// int 32 -- 0xd2
// int 64 -- 0xd3
token[0xd0] = writeN(0xd0, 1, Buffer.prototype.writeInt8);
token[0xd1] = writeN(0xd1, 2, Buffer.prototype.writeInt16BE);
token[0xd2] = writeN(0xd2, 4, Buffer.prototype.writeInt32BE);
token[0xd3] = writeN(0xd3, 8, writeInt64BE);
// str 8 -- 0xd9
// str 16 -- 0xda
// str 32 -- 0xdb
token[0xd9] = writeN(0xd9, 1, Buffer.prototype.writeUInt8);
token[0xda] = writeN(0xda, 2, Buffer.prototype.writeUInt16BE);
token[0xdb] = writeN(0xdb, 4, Buffer.prototype.writeUInt32BE);
// array 16 -- 0xdc
// array 32 -- 0xdd
token[0xdc] = writeN(0xdc, 2, Buffer.prototype.writeUInt16BE);
token[0xdd] = writeN(0xdd, 4, Buffer.prototype.writeUInt32BE);
// map 16 -- 0xde
// map 32 -- 0xdf
token[0xde] = writeN(0xde, 2, Buffer.prototype.writeUInt16BE);
token[0xdf] = writeN(0xdf, 4, Buffer.prototype.writeUInt32BE);
return token;
}
function write1(type) {
return function(encoder, value) {
var offset = encoder.reserve(2);
var buffer = encoder.buffer;
buffer[offset++] = type;
buffer[offset] = value;
};
}
function write2(type) {
return function(encoder, value) {
var offset = encoder.reserve(3);
var buffer = encoder.buffer;
buffer[offset++] = type;
buffer[offset++] = value >>> 8;
buffer[offset] = value;
};
}
function write4(type) {
return function(encoder, value) {
var offset = encoder.reserve(5);
var buffer = encoder.buffer;
buffer[offset++] = type;
buffer[offset++] = value >>> 24;
buffer[offset++] = value >>> 16;
buffer[offset++] = value >>> 8;
buffer[offset] = value;
};
}
function writeN(type, len, method, noAssert) {
return function(encoder, value) {
var offset = encoder.reserve(len + 1);
encoder.buffer[offset++] = type;
method.call(encoder.buffer, value, offset, noAssert);
};
}
function writeUInt64BE(value, offset) {
new Uint64BE(this, offset, value);
}
function writeInt64BE(value, offset) {
new Int64BE(this, offset, value);
}
function writeFloatBE(value, offset) {
ieee754.write(this, value, offset, false, 23, 4);
}
function writeDoubleBE(value, offset) {
ieee754.write(this, value, offset, false, 52, 8);
}

269
node_modules/msgpack-lite/lib/write-type.js generated vendored Normal file
View File

@@ -0,0 +1,269 @@
// write-type.js
var IS_ARRAY = require("isarray");
var Int64Buffer = require("int64-buffer");
var Uint64BE = Int64Buffer.Uint64BE;
var Int64BE = Int64Buffer.Int64BE;
var Bufferish = require("./bufferish");
var BufferProto = require("./bufferish-proto");
var WriteToken = require("./write-token");
var uint8 = require("./write-uint8").uint8;
var ExtBuffer = require("./ext-buffer").ExtBuffer;
var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
var HAS_MAP = ("undefined" !== typeof Map);
var extmap = [];
extmap[1] = 0xd4;
extmap[2] = 0xd5;
extmap[4] = 0xd6;
extmap[8] = 0xd7;
extmap[16] = 0xd8;
exports.getWriteType = getWriteType;
function getWriteType(options) {
var token = WriteToken.getWriteToken(options);
var useraw = options && options.useraw;
var binarraybuffer = HAS_UINT8ARRAY && options && options.binarraybuffer;
var isBuffer = binarraybuffer ? Bufferish.isArrayBuffer : Bufferish.isBuffer;
var bin = binarraybuffer ? bin_arraybuffer : bin_buffer;
var usemap = HAS_MAP && options && options.usemap;
var map = usemap ? map_to_map : obj_to_map;
var writeType = {
"boolean": bool,
"function": nil,
"number": number,
"object": (useraw ? object_raw : object),
"string": _string(useraw ? raw_head_size : str_head_size),
"symbol": nil,
"undefined": nil
};
return writeType;
// false -- 0xc2
// true -- 0xc3
function bool(encoder, value) {
var type = value ? 0xc3 : 0xc2;
token[type](encoder, value);
}
function number(encoder, value) {
var ivalue = value | 0;
var type;
if (value !== ivalue) {
// float 64 -- 0xcb
type = 0xcb;
token[type](encoder, value);
return;
} else if (-0x20 <= ivalue && ivalue <= 0x7F) {
// positive fixint -- 0x00 - 0x7f
// negative fixint -- 0xe0 - 0xff
type = ivalue & 0xFF;
} else if (0 <= ivalue) {
// uint 8 -- 0xcc
// uint 16 -- 0xcd
// uint 32 -- 0xce
type = (ivalue <= 0xFF) ? 0xcc : (ivalue <= 0xFFFF) ? 0xcd : 0xce;
} else {
// int 8 -- 0xd0
// int 16 -- 0xd1
// int 32 -- 0xd2
type = (-0x80 <= ivalue) ? 0xd0 : (-0x8000 <= ivalue) ? 0xd1 : 0xd2;
}
token[type](encoder, ivalue);
}
// uint 64 -- 0xcf
function uint64(encoder, value) {
var type = 0xcf;
token[type](encoder, value.toArray());
}
// int 64 -- 0xd3
function int64(encoder, value) {
var type = 0xd3;
token[type](encoder, value.toArray());
}
// str 8 -- 0xd9
// str 16 -- 0xda
// str 32 -- 0xdb
// fixstr -- 0xa0 - 0xbf
function str_head_size(length) {
return (length < 32) ? 1 : (length <= 0xFF) ? 2 : (length <= 0xFFFF) ? 3 : 5;
}
// raw 16 -- 0xda
// raw 32 -- 0xdb
// fixraw -- 0xa0 - 0xbf
function raw_head_size(length) {
return (length < 32) ? 1 : (length <= 0xFFFF) ? 3 : 5;
}
function _string(head_size) {
return string;
function string(encoder, value) {
// prepare buffer
var length = value.length;
var maxsize = 5 + length * 3;
encoder.offset = encoder.reserve(maxsize);
var buffer = encoder.buffer;
// expected header size
var expected = head_size(length);
// expected start point
var start = encoder.offset + expected;
// write string
length = BufferProto.write.call(buffer, value, start);
// actual header size
var actual = head_size(length);
// move content when needed
if (expected !== actual) {
var targetStart = start + actual - expected;
var end = start + length;
BufferProto.copy.call(buffer, buffer, targetStart, start, end);
}
// write header
var type = (actual === 1) ? (0xa0 + length) : (actual <= 3) ? (0xd7 + actual) : 0xdb;
token[type](encoder, length);
// move cursor
encoder.offset += length;
}
}
function object(encoder, value) {
// null
if (value === null) return nil(encoder, value);
// Buffer
if (isBuffer(value)) return bin(encoder, value);
// Array
if (IS_ARRAY(value)) return array(encoder, value);
// int64-buffer objects
if (Uint64BE.isUint64BE(value)) return uint64(encoder, value);
if (Int64BE.isInt64BE(value)) return int64(encoder, value);
// ext formats
var packer = encoder.codec.getExtPacker(value);
if (packer) value = packer(value);
if (value instanceof ExtBuffer) return ext(encoder, value);
// plain old Objects or Map
map(encoder, value);
}
function object_raw(encoder, value) {
// Buffer
if (isBuffer(value)) return raw(encoder, value);
// others
object(encoder, value);
}
// nil -- 0xc0
function nil(encoder, value) {
var type = 0xc0;
token[type](encoder, value);
}
// fixarray -- 0x90 - 0x9f
// array 16 -- 0xdc
// array 32 -- 0xdd
function array(encoder, value) {
var length = value.length;
var type = (length < 16) ? (0x90 + length) : (length <= 0xFFFF) ? 0xdc : 0xdd;
token[type](encoder, length);
var encode = encoder.codec.encode;
for (var i = 0; i < length; i++) {
encode(encoder, value[i]);
}
}
// bin 8 -- 0xc4
// bin 16 -- 0xc5
// bin 32 -- 0xc6
function bin_buffer(encoder, value) {
var length = value.length;
var type = (length < 0xFF) ? 0xc4 : (length <= 0xFFFF) ? 0xc5 : 0xc6;
token[type](encoder, length);
encoder.send(value);
}
function bin_arraybuffer(encoder, value) {
bin_buffer(encoder, new Uint8Array(value));
}
// fixext 1 -- 0xd4
// fixext 2 -- 0xd5
// fixext 4 -- 0xd6
// fixext 8 -- 0xd7
// fixext 16 -- 0xd8
// ext 8 -- 0xc7
// ext 16 -- 0xc8
// ext 32 -- 0xc9
function ext(encoder, value) {
var buffer = value.buffer;
var length = buffer.length;
var type = extmap[length] || ((length < 0xFF) ? 0xc7 : (length <= 0xFFFF) ? 0xc8 : 0xc9);
token[type](encoder, length);
uint8[value.type](encoder);
encoder.send(buffer);
}
// fixmap -- 0x80 - 0x8f
// map 16 -- 0xde
// map 32 -- 0xdf
function obj_to_map(encoder, value) {
var keys = Object.keys(value);
var length = keys.length;
var type = (length < 16) ? (0x80 + length) : (length <= 0xFFFF) ? 0xde : 0xdf;
token[type](encoder, length);
var encode = encoder.codec.encode;
keys.forEach(function(key) {
encode(encoder, key);
encode(encoder, value[key]);
});
}
// fixmap -- 0x80 - 0x8f
// map 16 -- 0xde
// map 32 -- 0xdf
function map_to_map(encoder, value) {
if (!(value instanceof Map)) return obj_to_map(encoder, value);
var length = value.size;
var type = (length < 16) ? (0x80 + length) : (length <= 0xFFFF) ? 0xde : 0xdf;
token[type](encoder, length);
var encode = encoder.codec.encode;
value.forEach(function(val, key, m) {
encode(encoder, key);
encode(encoder, val);
});
}
// raw 16 -- 0xda
// raw 32 -- 0xdb
// fixraw -- 0xa0 - 0xbf
function raw(encoder, value) {
var length = value.length;
var type = (length < 32) ? (0xa0 + length) : (length <= 0xFFFF) ? 0xda : 0xdb;
token[type](encoder, length);
encoder.send(value);
}
}

14
node_modules/msgpack-lite/lib/write-uint8.js generated vendored Normal file
View File

@@ -0,0 +1,14 @@
// write-unit8.js
var constant = exports.uint8 = new Array(256);
for (var i = 0x00; i <= 0xFF; i++) {
constant[i] = write0(i);
}
function write0(type) {
return function(encoder) {
var offset = encoder.reserve(1);
encoder.buffer[offset] = type;
};
}

77
node_modules/msgpack-lite/package.json generated vendored Normal file
View File

@@ -0,0 +1,77 @@
{
"name": "msgpack-lite",
"description": "Fast Pure JavaScript MessagePack Encoder and Decoder",
"version": "0.1.26",
"author": "@kawanet",
"bin": {
"msgpack": "./bin/msgpack"
},
"browser": "lib/browser.js",
"bugs": {
"url": "https://github.com/kawanet/msgpack-lite/issues"
},
"contributors": [
"Christopher Vermilion <chris@figlyinc.com>",
"Frederik Dudzik <4004blog@gmail.com>",
"Garrett Serack <gserack@gmail.com>",
"Jesse Armand <jesse@jessearmand.com>",
"Joshua Wise <josh@joshuawise.ninja>",
"Maciej Hirsz <maciej.hirsz@gmail.com>"
],
"dependencies": {
"event-lite": "^0.1.1",
"ieee754": "^1.1.8",
"int64-buffer": "^0.1.9",
"isarray": "^1.0.0"
},
"devDependencies": {
"async": "^2.1.1",
"browserify": "^13.1.0",
"concat-stream": "^1.5.2",
"jshint": "^2.9.3",
"mocha": "^3.1.2",
"msgpack.codec": "git+https://github.com/kawanet/msgpack-javascript.git#msgpack.codec",
"uglify-js": "^2.7.3",
"zuul": "^3.11.1"
},
"homepage": "https://github.com/kawanet/msgpack-lite",
"jshintConfig": {
"es3": true,
"globals": {
"JSON": true,
"Symbol": true,
"Map": true,
"window": true
},
"mocha": true,
"node": true,
"undef": true
},
"keywords": [
"arraybuffer",
"buffer",
"fluentd",
"messagepack",
"msgpack",
"serialize",
"stream",
"typedarray",
"uint8array"
],
"license": "MIT",
"main": "index.js",
"repository": {
"type": "git",
"url": "https://github.com/kawanet/msgpack-lite.git"
},
"scripts": {
"benchmark": "./lib/benchmark.js",
"benchmark-lite": "./lib/benchmark.js msgpack-lite",
"benchmark-stream": "./lib/benchmark-stream.js",
"fixpack": "fixpack",
"make": "make",
"size": "make clean dist/msgpack.min.js && gzip -9fkv dist/msgpack.min.js && ls -l dist",
"test": "make test",
"test-browser-local": "make test-browser-local"
}
}

218
node_modules/msgpack-lite/test/10.encode.js generated vendored Executable file
View File

@@ -0,0 +1,218 @@
#!/usr/bin/env mocha -R spec
var assert = require("assert");
var msgpackJS = "../index";
var isBrowser = ("undefined" !== typeof window);
var msgpack = isBrowser && window.msgpack || require(msgpackJS);
var TITLE = __filename.replace(/^.*\//, "");
var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
describe(TITLE, function() {
describe("Buffer", function() {
run_tests();
});
var describe_Uint8Array = HAS_UINT8ARRAY ? describe : describe.skip;
describe_Uint8Array("Uint8Array", function() {
run_tests({uint8array: true});
});
});
function run_tests(codecopt) {
var options;
if (codecopt) it(JSON.stringify(codecopt), function() {
var codec = msgpack.createCodec(codecopt);
assert.ok(codec);
options = {codec: codec};
});
// positive fixint -- 0x00 - 0x7f
it("00-7f: positive fixint", function() {
for (var i = 0; i <= 0x7F; i++) {
assert.deepEqual(toArray(msgpack.encode(i, options)), [i]);
}
});
// fixmap -- 0x80 - 0x8f
it("80-8f: fixmap", function() {
var map = {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10, k: 11, l: 12, m: 13, n: 14, o: 15, p: 16};
var src = {};
var exp = [0x80];
Object.keys(map).forEach(function(key) {
assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
src[key] = map[key];
exp[0]++;
exp.push(0xa1);
exp.push(key.charCodeAt(0));
exp.push(map[key]);
});
});
// fixarray -- 0x90 - 0x9f
it("90-9f: fixarray", function() {
var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
var src = [];
var exp = [0x90];
for (var i = 0; i < 16; i++) {
assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
src.push(array[i]);
exp[0]++;
exp.push(array[i]);
}
});
// fixstr -- 0xa0 - 0xbf
it("a0-bf: fixstr", function() {
assert.deepEqual(toArray(msgpack.encode("", options)), [0xa0]);
var str = "0123456789abcdefghijklmnopqrstu";
var exp = [0xa0];
for (var i = 0; i < 32; i++) {
var src = str.substr(0, i);
assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
exp[0]++;
exp.push(str.charCodeAt(i));
}
});
// nil -- 0xc0
it("c0: nil (null)", function() {
assert.deepEqual(toArray(msgpack.encode(null, options)), [0xc0]);
});
it("c0: nil (undefined)", function() {
assert.deepEqual(toArray(msgpack.encode(undefined, options)), [0xc0]);
});
it("c0: nil (Function)", function() {
assert.deepEqual(toArray(msgpack.encode(NOP, options)), [0xc0]);
});
// false -- 0xc2
// true -- 0xc3
it("c2-c3: boolean", function() {
assert.deepEqual(toArray(msgpack.encode(false, options)), [0xc2]);
assert.deepEqual(toArray(msgpack.encode(true, options)), [0xc3]);
});
// bin 8 -- 0xc4
// bin 16 -- 0xc5
// bin 32 -- 0xc6
it("c4-c6: bin 8/16/32", function() {
this.timeout(30000);
var bin;
bin = Buffer(1);
bin.fill(0);
assert.deepEqual(toArray(msgpack.encode(bin, options)), concat([0xc4, 1], bin));
bin = Buffer(256);
bin.fill(0);
assert.deepEqual(toArray(msgpack.encode(bin, options)), concat([0xc5, 1, 0], bin));
bin = Buffer(65536);
bin.fill(0);
assert.deepEqual(toArray(msgpack.encode(bin, options)), concat([0xc6, 0, 1, 0, 0], bin));
});
// float 32 -- 0xca -- NOT SUPPORTED
// float 64 -- 0xcb
it("ca-cb: float 32/64", function() {
assert.deepEqual(toArray(msgpack.encode(0.5, options)), [0xcb, 63, 224, 0, 0, 0, 0, 0, 0]);
});
// uint 8 -- 0xcc
// uint 16 -- 0xcd
// uint 32 -- 0xce
// uint 64 -- 0xcf -- NOT SUPPORTED
it("cc-cf: uint 8/16/32/64", function() {
assert.deepEqual(toArray(msgpack.encode(0xFF, options)), [0xcc, 0xFF]);
assert.deepEqual(toArray(msgpack.encode(0xFFFF, options)), [0xcd, 0xFF, 0xFF]);
assert.deepEqual(toArray(msgpack.encode(0x7FFFFFFF, options)), [0xce, 0x7F, 0xFF, 0xFF, 0xFF]);
});
// int 8 -- 0xd0
// int 16 -- 0xd1
// int 32 -- 0xd2
// int 64 -- 0xd3 -- NOT SUPPORTED
it("d0-d3: int 8/16/32/64", function() {
assert.deepEqual(toArray(msgpack.encode(-0x80, options)), [0xd0, 0x80]);
assert.deepEqual(toArray(msgpack.encode(-0x8000, options)), [0xd1, 0x80, 0x00]);
assert.deepEqual(toArray(msgpack.encode(-0x80000000, options)), [0xd2, 0x80, 0x00, 0x00, 0x00]);
});
// str 8 -- 0xd9
// str 16 -- 0xda
// str 32 -- 0xdb
it("d9-db: str 8/16/32", function() {
this.timeout(30000);
var str, src = "a";
for (var i = 0; i < 17; i++) src += src;
str = src.substr(0, 0xFF);
assert.deepEqual(toArray(msgpack.encode(str, options)), concat([0xd9, 0xFF], Buffer(str)));
str = src.substr(0, 0x0100);
assert.deepEqual(toArray(msgpack.encode(str, options)), concat([0xda, 0x01, 0x00], Buffer(str)));
str = src.substr(0, 0xFFFF);
assert.deepEqual(toArray(msgpack.encode(str, options)), concat([0xda, 0xFF, 0xFF], Buffer(str)));
str = src.substr(0, 0x010000);
assert.deepEqual(toArray(msgpack.encode(str, options)), concat([0xdb, 0x00, 0x01, 0x00, 0x00], Buffer(str)));
});
// array 16 -- 0xdc
// array 32 -- 0xdd
it("dc-dd: array 16/32", function() {
this.timeout(30000);
var i, exp;
var src = new Array(256);
for (i = 0; i < 256; i++) src[i] = i & 0x7F;
exp = [0xdc, 0x01, 0x00].concat(src);
assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
for (i = 0; i < 8; i++) src = src.concat(src);
exp = [0xdd, 0x00, 0x01, 0x00, 0x00].concat(src);
assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
});
// map 16 -- 0xde
// map 32 -- 0xdf
it("de-df: map 16/32", function() {
this.timeout(30000);
var i, actual;
var map = {};
for (i = 0; i < 256; i++) map[i] = i;
actual = msgpack.encode(map, options);
// check only headers because order may vary
assert.equal(actual[0], 0xde);
assert.equal(actual[1], 1);
assert.equal(actual[2], 0);
for (i = 256; i < 65536; i++) map[i] = i;
actual = msgpack.encode(map, options);
assert.equal(actual[0], 0xdf);
assert.equal(actual[1], 0);
assert.equal(actual[2], 1);
assert.equal(actual[3], 0);
assert.equal(actual[4], 0);
});
// negative fixint -- 0xe0 - 0xff
it("e0-ff: negative fixint", function() {
for (var i = -32; i <= -1; i++) {
assert.deepEqual(toArray(msgpack.encode(i, options)), [i & 0xFF]);
}
});
}
function toArray(buffer) {
return Array.prototype.slice.call(buffer);
}
function concat(buf) {
return Array.prototype.concat.apply([], Array.prototype.map.call(arguments, toArray));
}
function NOP() {
}

371
node_modules/msgpack-lite/test/11.decode.js generated vendored Executable file
View File

@@ -0,0 +1,371 @@
#!/usr/bin/env mocha -R spec
var assert = require("assert");
var msgpackJS = "../index";
var isBrowser = ("undefined" !== typeof window);
var msgpack = isBrowser && window.msgpack || require(msgpackJS);
var TITLE = __filename.replace(/^.*\//, "");
var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
ArrayBridge.concat = ArrayBridge_concat;
Uint8ArrayBridge.concat = Uint8ArrayBridge_concat;
describe(TITLE, function() {
describe("Buffer", function() {
run_tests(Buffer);
});
describe("Array", function() {
run_tests(ArrayBridge);
});
var describe_Uint8Array = HAS_UINT8ARRAY ? describe : describe.skip;
describe_Uint8Array("Uint8Array", function() {
run_tests(Uint8ArrayBridge);
});
});
function run_tests(BUFFER) {
// positive fixint -- 0x00 - 0x7f
it("00-7f: positive fixint", function() {
for (var i = 0; i <= 0x7F; i++) {
assert.deepEqual(msgpack.decode(BUFFER([i])), i);
}
});
// fixmap -- 0x80 - 0x8f
it("80-8f: fixmap", function() {
var map = {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10, k: 11, l: 12, m: 13, n: 14, o: 15, p: 16};
var src = [0x80];
var exp = {};
Object.keys(map).forEach(function(key) {
assert.deepEqual(msgpack.decode(BUFFER(src)), exp);
src[0]++;
src.push(0xa1);
src.push(key.charCodeAt(0));
src.push(map[key]);
exp[key] = map[key];
});
});
// fixarray -- 0x90 - 0x9f
it("90-9f: fixarray", function() {
var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
var src = [0x90];
var exp = [];
for (var i = 0; i < 16; i++) {
assert.deepEqual(msgpack.decode(BUFFER(src)), exp);
src[0]++;
src.push(array[i]);
exp.push(array[i]);
}
});
// fixstr -- 0xa0 - 0xbf
it("a0-bf: fixstr", function() {
var str = "0123456789abcdefghijklmnopqrstu";
var src = [0xa0];
for (var i = 0; i < 32; i++) {
var exp = str.substr(0, i);
assert.deepEqual(msgpack.decode(BUFFER(src)), exp);
src[0]++;
src.push(str.charCodeAt(i));
}
});
// nil -- 0xc0
it("c0: nil", function() {
assert.deepEqual(msgpack.decode(BUFFER([0xc0])), null);
});
// (never used) -- 0xc1
it("c1: (never used)", function(done) {
try {
msgpack.decode(BUFFER([0xc1]));
done("should throw");
} catch (e) {
done();
}
});
// false -- 0xc2
// true -- 0xc3
it("c2-c3: boolean", function() {
assert.equal(msgpack.decode(BUFFER([0xc2])), false);
assert.equal(msgpack.decode(BUFFER([0xc3])), true);
});
// bin 8 -- 0xc4
// bin 16 -- 0xc5
// bin 32 -- 0xc6
it("c4-c6: bin 8/16/32", function() {
this.timeout(30000);
var bin, buf, act;
bin = BUFFER(1);
buf = BUFFER.concat([BUFFER([0xc4, 1]), bin]);
act = msgpack.decode(buf);
assert.ok(Buffer.isBuffer(act));
assert.deepEqual(ArrayBridge(act), ArrayBridge(bin));
bin = BUFFER(256);
buf = BUFFER.concat([BUFFER([0xc5, 1, 0]), bin]);
act = msgpack.decode(buf);
assert.ok(Buffer.isBuffer(act));
assert.deepEqual(ArrayBridge(act), ArrayBridge(bin));
bin = BUFFER(65536);
buf = BUFFER.concat([BUFFER([0xc6, 0, 1, 0, 0]), bin]);
act = msgpack.decode(buf);
assert.ok(Buffer.isBuffer(act));
assert.deepEqual(ArrayBridge(act), ArrayBridge(bin));
});
// ext 8 -- 0xc7
// ext 16 -- 0xc8
// ext 32 -- 0xc9
it("c7-c9: ext 8/16/32", function() {
this.timeout(30000);
var ext, buf, act;
ext = BUFFER(1);
buf = BUFFER.concat([BUFFER([0xc7, 1, 0]), ext]);
act = msgpack.decode(buf);
assert.ok(Buffer.isBuffer(act.buffer));
assert.deepEqual(ArrayBridge(act.buffer), ArrayBridge(ext));
ext = BUFFER(256);
buf = BUFFER.concat([BUFFER([0xc8, 1, 0, 0]), ext]);
act = msgpack.decode(buf);
assert.ok(Buffer.isBuffer(act.buffer));
assert.deepEqual(ArrayBridge(act.buffer), ArrayBridge(ext));
ext = BUFFER(65536);
buf = BUFFER.concat([BUFFER([0xc9, 0, 1, 0, 0, 0]), ext]);
act = msgpack.decode(buf);
assert.ok(Buffer.isBuffer(act.buffer));
assert.deepEqual(ArrayBridge(act.buffer), ArrayBridge(ext));
});
// float 32 -- 0xca
// float 64 -- 0xcb
it("ca-cb: float 32/64", function() {
var buf;
buf = Buffer(5);
buf.writeUInt8(0xCA, 0);
buf.writeFloatBE(0.5, 1);
assert.deepEqual(msgpack.decode(BUFFER(buf)), 0.5);
buf = Buffer(9);
buf.writeUInt8(0xCB, 0);
buf.writeDoubleBE(0.5, 1);
assert.deepEqual(msgpack.decode(BUFFER(buf)), 0.5);
});
// uint 8 -- 0xcc
// uint 16 -- 0xcd
// uint 32 -- 0xce
// uint 64 -- 0xcf
it("cc-cf: uint 8/16/32/64", function() {
assert.deepEqual(msgpack.decode(BUFFER([0xcc, 0x01])), 0x01);
assert.deepEqual(msgpack.decode(BUFFER([0xcc, 0xFF])), 0xFF);
assert.deepEqual(msgpack.decode(BUFFER([0xcd, 0x00, 0x01])), 0x0001);
assert.deepEqual(msgpack.decode(BUFFER([0xcd, 0xFF, 0xFF])), 0xFFFF);
assert.deepEqual(msgpack.decode(BUFFER([0xce, 0x00, 0x00, 0x00, 0x01])), 0x00000001);
assert.deepEqual(msgpack.decode(BUFFER([0xce, 0x7F, 0xFF, 0xFF, 0xFF])), 0x7FFFFFFF);
assert.deepEqual(msgpack.decode(BUFFER([0xce, 0xFF, 0xFF, 0xFF, 0xFF])), 0xFFFFFFFF);
assert.deepEqual(msgpack.decode(BUFFER([0xce, 0x12, 0x34, 0x56, 0x78])), 0x12345678);
assert.deepEqual(msgpack.decode(BUFFER([0xcf, 0, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF])), 0x00000000FFFFFFFF);
assert.deepEqual(msgpack.decode(BUFFER([0xcf, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF, 0, 0])), 0x0000FFFFFFFF0000);
assert.deepEqual(msgpack.decode(BUFFER([0xcf, 0xFF, 0xFF, 0xFF, 0xFF, 0, 0, 0, 0])), 0xFFFFFFFF00000000);
});
// int 8 -- 0xd0
// int 16 -- 0xd1
// int 32 -- 0xd2
// int 64 -- 0xd3
it("d0-d3: int 8/16/32/64", function() {
assert.deepEqual(msgpack.decode(BUFFER([0xd0, 0x7F])), 0x7F);
assert.deepEqual(msgpack.decode(BUFFER([0xd0, 0x80])), -0x80);
assert.deepEqual(msgpack.decode(BUFFER([0xd0, 0xFF])), -1);
assert.deepEqual(msgpack.decode(BUFFER([0xd1, 0x7F, 0xFF])), 0x7FFF);
assert.deepEqual(msgpack.decode(BUFFER([0xd1, 0x80, 0x00])), -0x8000);
assert.deepEqual(msgpack.decode(BUFFER([0xd1, 0xFF, 0xFF])), -1);
assert.deepEqual(msgpack.decode(BUFFER([0xd2, 0x7F, 0xFF, 0xFF, 0xFF])), 0x7FFFFFFF);
assert.deepEqual(msgpack.decode(BUFFER([0xd2, 0x80, 0x00, 0x00, 0x00])), -0x80000000);
assert.deepEqual(msgpack.decode(BUFFER([0xd2, 0xFF, 0xFF, 0xFF, 0xFF])), -1);
assert.deepEqual(msgpack.decode(BUFFER([0xd2, 0x12, 0x34, 0x56, 0x78])), 0x12345678);
assert.deepEqual(msgpack.decode(BUFFER([0xd3, 0, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF])), 0x00000000FFFFFFFF);
assert.deepEqual(msgpack.decode(BUFFER([0xd3, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF, 0, 0])), 0x0000FFFFFFFF0000);
assert.deepEqual(msgpack.decode(BUFFER([0xd3, 0x7F, 0xFF, 0xFF, 0xFF, 0, 0, 0, 0])), 0x7FFFFFFF00000000);
assert.deepEqual(msgpack.decode(BUFFER([0xd3, 0x80, 0, 0, 0, 0, 0, 0, 0])), -0x8000000000000000);
assert.deepEqual(msgpack.decode(BUFFER([0xd3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF])), -1);
});
// fixext 1 -- 0xd4
// fixext 2 -- 0xd5
// fixext 4 -- 0xd6
// fixext 8 -- 0xd7
// fixext 16 -- 0xd8
it("d4-d8: fixext 1/2/4/8/16", function() {
var ext, buf, act;
ext = BUFFER(1);
buf = BUFFER.concat([BUFFER([0xd4, 0]), ext]);
act = msgpack.decode(buf);
assert.ok(Buffer.isBuffer(act.buffer));
assert.deepEqual(ArrayBridge(act.buffer), ArrayBridge(ext));
ext = BUFFER(2);
buf = BUFFER.concat([BUFFER([0xd5, 0]), ext]);
act = msgpack.decode(buf);
assert.ok(Buffer.isBuffer(act.buffer));
assert.deepEqual(ArrayBridge(act.buffer), ArrayBridge(ext));
ext = BUFFER(4);
buf = BUFFER.concat([BUFFER([0xd6, 0]), ext]);
act = msgpack.decode(buf);
assert.ok(Buffer.isBuffer(act.buffer));
assert.deepEqual(ArrayBridge(act.buffer), ArrayBridge(ext));
ext = BUFFER(8);
buf = BUFFER.concat([BUFFER([0xd7, 0]), ext]);
act = msgpack.decode(buf);
assert.ok(Buffer.isBuffer(act.buffer));
assert.deepEqual(ArrayBridge(act.buffer), ArrayBridge(ext));
ext = BUFFER(16);
buf = BUFFER.concat([BUFFER([0xd8, 0]), ext]);
act = msgpack.decode(buf);
assert.ok(Buffer.isBuffer(act.buffer));
assert.deepEqual(ArrayBridge(act.buffer), ArrayBridge(ext));
});
// str 8 -- 0xd9
// str 16 -- 0xda
// str 32 -- 0xdb
it("d9-db: str 8/16/32", function() {
this.timeout(30000);
var str, buf, src = "a";
for (var i = 0; i < 17; i++) src += src;
str = src.substr(0, 0xFF);
buf = BUFFER.concat([BUFFER([0xd9, 0xFF]), BUFFER(str)]);
assert.deepEqual(msgpack.decode(buf), str);
str = src.substr(0, 0x0100);
buf = BUFFER.concat([BUFFER([0xda, 0x01, 0x00]), BUFFER(str)]);
assert.deepEqual(msgpack.decode(buf), str);
str = src.substr(0, 0xFFFF);
buf = BUFFER.concat([BUFFER([0xda, 0xFF, 0xFF]), BUFFER(str)]);
assert.deepEqual(msgpack.decode(buf), str);
str = src.substr(0, 0x010000);
buf = BUFFER.concat([BUFFER([0xdb, 0x00, 0x01, 0x00, 0x00]), BUFFER(str)]);
assert.deepEqual(msgpack.decode(buf), str);
});
// array 16 -- 0xdc
// array 32 -- 0xdd
it("dc-dd: array 16/32", function() {
this.timeout(30000);
var i, src;
var array = new Array(256);
for (i = 0; i < 256; i++) array[i] = i & 0x7F;
src = [0xdc, 0x01, 0x00].concat(array);
assert.deepEqual(msgpack.decode(BUFFER(src)), array);
for (i = 0; i < 8; i++) array = array.concat(array);
src = [0xdd, 0x00, 0x01, 0x00, 0x00].concat(array);
assert.deepEqual(msgpack.decode(BUFFER(src)), array);
});
// map 16 -- 0xde
// map 32 -- 0xdf
it("de-df: map 16/32", function() {
this.timeout(30000);
var i, src, key;
var map = {};
var array = [];
for (i = 0; i < 256; i++) {
key = i.toString(16);
if (i < 16) key = "0" + key;
map[key] = i & 0x7F;
array.push(0xa2);
array.push(key.charCodeAt(0));
array.push(key.charCodeAt(1));
array.push(i & 0x7F);
}
src = [0xde, 0x01, 0x00].concat(array);
assert.deepEqual(msgpack.decode(BUFFER(src)), map);
for (i = 0; i < 8; i++) array = array.concat(array);
src = [0xdf, 0x00, 0x01, 0x00, 0x00].concat(array);
assert.deepEqual(msgpack.decode(BUFFER(src)), map);
});
// negative fixint -- 0xe0 - 0xff
it("e0-ff: negative fixint", function() {
for (var i = -32; i <= -1; i++) {
assert.deepEqual(msgpack.decode(BUFFER([i & 0xFF])), i);
}
});
}
function ArrayBridge(array) {
if ("number" === typeof array) {
array = init_seq([], array);
} else if ("string" === typeof array) {
array = copy_string([], array);
} else if (Buffer.isBuffer(array) || (HAS_UINT8ARRAY && (array instanceof Uint8Array))) {
array = copy_array([], array);
}
return array;
}
function init_seq(array, length) {
for (var i = 0; i < length; i++) {
array[i] = i & 255;
}
return array;
}
function copy_string(array, src) {
for (var i = 0; i < src.length; i++) {
array[i] = src.charCodeAt(i);
}
return array;
}
function copy_array(array, src) {
for (var i = 0; i < src.length; i++) {
array[i] = src[i];
}
return array;
}
function ArrayBridge_concat(pair) {
return Array.prototype.concat.apply([], pair);
}
function Uint8ArrayBridge(array) {
if ("number" === typeof array) {
array = init_seq(new Uint8Array(array), array);
} else if ("string" === typeof array) {
array = copy_string(new Uint8Array(array.length), array);
} else if (Buffer.isBuffer(array)) {
array = copy_array(new Uint8Array(array.length), array);
} else {
array = new Uint8Array(array);
}
return array;
}
function Uint8ArrayBridge_concat(pair) {
return Uint8ArrayBridge(ArrayBridge_concat(pair.map(ArrayBridge)));
}

36
node_modules/msgpack-lite/test/12.encoder.js generated vendored Executable file
View File

@@ -0,0 +1,36 @@
#!/usr/bin/env mocha -R spec
var assert = require("assert");
var msgpackJS = "../index";
var isBrowser = ("undefined" !== typeof window);
var msgpack = isBrowser && window.msgpack || require(msgpackJS);
var TITLE = __filename.replace(/^.*\//, "");
var source = {"foo": "bar"};
var packed = toArray(msgpack.encode(source));
describe(TITLE, function() {
it("Encoder().encode(obj)", function(done) {
var encoder = new msgpack.Encoder();
encoder.on("data", function(data) {
assert.deepEqual(toArray(data), packed);
});
encoder.on("end", done);
encoder.encode(source);
encoder.end();
});
it("Encoder().end(obj)", function(done) {
var encoder = new msgpack.Encoder();
encoder.on("data", function(data) {
assert.deepEqual(toArray(data), packed);
});
encoder.on("end", done);
encoder.end(source);
});
});
function toArray(buffer) {
return Array.prototype.slice.call(buffer);
}

32
node_modules/msgpack-lite/test/13.decoder.js generated vendored Executable file
View File

@@ -0,0 +1,32 @@
#!/usr/bin/env mocha -R spec
var assert = require("assert");
var msgpackJS = "../index";
var isBrowser = ("undefined" !== typeof window);
var msgpack = isBrowser && window.msgpack || require(msgpackJS);
var TITLE = __filename.replace(/^.*\//, "");
var source = {"foo": "bar"};
var packed = msgpack.encode(source);
describe(TITLE, function() {
it("Decoder().decode(obj)", function(done) {
var decoder = new msgpack.Decoder();
decoder.on("data", function(data) {
assert.deepEqual(data, source);
});
decoder.on("end", done);
decoder.decode(packed);
decoder.end();
});
it("Decoder().end(obj)", function(done) {
var decoder = new msgpack.Decoder();
decoder.on("data", function(data) {
assert.deepEqual(data, source);
});
decoder.on("end", done);
decoder.end(packed);
});
});

95
node_modules/msgpack-lite/test/14.codec.js generated vendored Executable file
View File

@@ -0,0 +1,95 @@
#!/usr/bin/env mocha -R spec
var assert = require("assert");
var msgpackJS = "../index";
var isBrowser = ("undefined" !== typeof window);
var msgpack = isBrowser && window.msgpack || require(msgpackJS);
var TITLE = __filename.replace(/^.*\//, "");
var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
describe(TITLE, function() {
it("createCodec()", function() {
var codec = msgpack.createCodec();
var options = {codec: codec};
assert.ok(codec);
// this codec does not have preset codec
for (var i = 0; i < 256; i++) {
test(i);
}
function test(type) {
// fixext 1 -- 0xd4
var source = new Buffer([0xd4, type, type]);
var decoded = msgpack.decode(source, options);
assert.equal(decoded.type, type);
assert.equal(decoded.buffer.length, 1);
var encoded = msgpack.encode(decoded, options);
assert.deepEqual(toArray(encoded), toArray(source));
}
});
it("addExtPacker()", function() {
var codec = msgpack.createCodec();
codec.addExtPacker(0, MyClass, myClassPacker);
codec.addExtUnpacker(0, myClassUnpacker);
var options = {codec: codec};
[0, 1, 127, 255].forEach(test);
function test(type) {
var source = new MyClass(type);
var encoded = msgpack.encode(source, options);
var decoded = msgpack.decode(encoded, options);
assert.ok(decoded instanceof MyClass);
assert.equal(decoded.value, type);
}
});
// The safe mode works as same as the default mode. It'd be hard for test it.
it("createCodec({safe: true})", function() {
var options = {codec: msgpack.createCodec({safe: true})};
var source = 1;
var encoded = msgpack.encode(source, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(decoded, source);
});
it("createCodec({preset: true})", function() {
var options1 = {codec: msgpack.createCodec({preset: true})};
var options2 = {codec: msgpack.createCodec({preset: false})};
var source = new Date();
var encoded = msgpack.encode(source, options1);
assert.equal(encoded[0], 0xC7, "preset ext format failure. (128 means map format)"); // ext 8
assert.equal(encoded[1], 0x09); // 1+8
assert.equal(encoded[2], 0x0D); // Date
// decode as Boolean instance
var decoded = msgpack.decode(encoded, options1);
assert.equal(decoded - 0, source - 0);
assert.ok(decoded instanceof Date);
// decode as ExtBuffer
decoded = msgpack.decode(encoded, options2);
assert.ok(!(decoded instanceof Date));
assert.equal(decoded.type, 0x0D);
});
});
function MyClass(value) {
this.value = value & 0xFF;
}
function myClassPacker(obj) {
return new Buffer([obj.value]);
}
function myClassUnpacker(buffer) {
return new MyClass(buffer[0]);
}
function toArray(array) {
if (HAS_UINT8ARRAY && array instanceof ArrayBuffer) array = new Uint8Array(array);
return Array.prototype.slice.call(array);
}

92
node_modules/msgpack-lite/test/15.useraw.js generated vendored Executable file
View File

@@ -0,0 +1,92 @@
#!/usr/bin/env mocha -R spec
var assert = require("assert");
var msgpackJS = "../index";
var isBrowser = ("undefined" !== typeof window);
var msgpack = isBrowser && window.msgpack || require(msgpackJS);
var TITLE = __filename.replace(/^.*\//, "");
var TESTS = [0, 1, 31, 32, 255, 256, 65535, 65536];
function toArray(array) {
return Array.prototype.slice.call(array);
}
describe(TITLE, function() {
var options;
it("useraw (decode)", function() {
options = {codec: msgpack.createCodec({useraw: true})};
// raw
assert.deepEqual(toArray(msgpack.decode(new Buffer([0xa1, 65]), options)), [65]);
// str
assert.equal(msgpack.decode(new Buffer([0xa1, 65])), "A");
});
it("useraw (encode)", function() {
// raw (String)
assert.deepEqual(toArray(msgpack.encode("A", options)), [0xa1, 65]);
// raw (Buffer)
assert.deepEqual(toArray(msgpack.encode(new Buffer([65]), options)), [0xa1, 65]);
// str
assert.deepEqual(toArray(msgpack.encode("A")), [0xa1, 65]);
});
it("useraw (String)", function() {
TESTS.forEach(test);
function test(length) {
var source = "";
for (var i = 0; i < length; i++) {
source += "a";
}
// encode as raw
var encoded = msgpack.encode(source, options);
assert.ok(encoded.length);
// decode as raw (Buffer)
var buffer = msgpack.decode(encoded, options);
assert.ok(Buffer.isBuffer(buffer));
assert.equal(buffer.length, length);
if (length) assert.equal(buffer[0], 97);
// decode as str (String)
var string = msgpack.decode(encoded);
assert.equal(typeof string, "string");
assert.equal(string.length, length);
assert.equal(string, source);
}
});
it("useraw (Buffer)", function() {
TESTS.forEach(test);
function test(length) {
var source = new Buffer(length);
for (var i = 0; i < length; i++) {
source[i] = 65; // "A"
}
// encode as raw
var encoded = msgpack.encode(source, options);
assert.ok(encoded.length);
// decode as raw (Buffer)
var buffer = msgpack.decode(encoded, options);
assert.ok(Buffer.isBuffer(buffer));
assert.equal(buffer.length, length);
if (length) assert.equal(buffer[0], 65);
// decode as str (String)
var string = msgpack.decode(encoded);
assert.equal(typeof string, "string");
assert.equal(string.length, length);
if (length) assert.equal(string[0], "A");
}
});
});

91
node_modules/msgpack-lite/test/16.binarraybuffer.js generated vendored Executable file
View File

@@ -0,0 +1,91 @@
#!/usr/bin/env mocha -R spec
var assert = require("assert");
var msgpackJS = "../index";
var isBrowser = ("undefined" !== typeof window);
var msgpack = isBrowser && window.msgpack || require(msgpackJS);
var TITLE = __filename.replace(/^.*\//, "");
var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
var TESTS = [0, 1, 31, 32, 255, 256, 65535, 65536];
function toArray(array) {
if (array instanceof ArrayBuffer) array = new Uint8Array(array);
return Array.prototype.slice.call(array);
}
// run this test when Uint8Array is available
var describeSkip = HAS_UINT8ARRAY ? describe : describe.skip;
describeSkip(TITLE, function() {
var options;
it("binarraybuffer (decode)", function() {
var decoded;
options = {codec: msgpack.createCodec({binarraybuffer: true, preset: true})};
// bin (Buffer)
decoded = msgpack.decode(new Buffer([0xc4, 2, 65, 66]), options);
assert.ok(decoded instanceof ArrayBuffer);
assert.ok(!Buffer.isBuffer(decoded));
assert.deepEqual(toArray(decoded), [65, 66]);
// bin (Uint8Array)
decoded = msgpack.decode(new Uint8Array([0xc4, 2, 97, 98]), options);
assert.ok(decoded instanceof ArrayBuffer);
assert.ok(!Buffer.isBuffer(decoded));
assert.deepEqual(toArray(decoded), [97, 98]);
// bin (Array)
decoded = msgpack.decode([0xc4, 2, 65, 66], options);
assert.ok(decoded instanceof ArrayBuffer);
assert.ok(!Buffer.isBuffer(decoded));
assert.deepEqual(toArray(decoded), [65, 66]);
});
it("binarraybuffer (encode)", function() {
// bin (ArrayBuffer)
var encoded = msgpack.encode(new Uint8Array([65, 66]).buffer, options);
assert.deepEqual(toArray(encoded), [0xc4, 2, 65, 66]);
});
it("binarraybuffer (large)", function() {
TESTS.forEach(test);
function test(length) {
var source = new Uint8Array(length);
for (var i = 0; i < length; i++) {
source[i] = 65; // "A"
}
var encoded = msgpack.encode(source.buffer, options);
assert.ok(encoded.length);
var decoded = msgpack.decode(encoded, options);
assert.ok(decoded instanceof ArrayBuffer);
assert.ok(!Buffer.isBuffer(decoded));
decoded = new Uint8Array(decoded);
assert.equal(decoded.length, length);
if (length) assert.equal(decoded[0], 65);
}
});
// addExtPacker() and getExtPacker() methods need a valid constructor name.
// IE10 and iOS7 Safari may give another constructor name than Buffer.
// At those cases, below will be encoded as Uint8Array: [0xd5, 0x12, 97, 98]
var b = new Buffer(1);
var c = b.constructor;
var d = (c && c.name === "Buffer") ? it : it.skip;
d("encode Buffer ext format 0x1B", function() {
// fixext 2 (Buffer)
var encoded = msgpack.encode(new Buffer([97, 98]), options);
assert.deepEqual(toArray(encoded), [0xd5, 0x1b, 97, 98]);
});
it("decode Buffer ext format 0x1B", function() {
// fixext 2 (Buffer)
var decoded = msgpack.decode([0xd5, 0x1b, 65, 66], options);
assert.ok(Buffer.isBuffer(decoded));
assert.deepEqual(toArray(decoded), [65, 66]);
});
});

43
node_modules/msgpack-lite/test/17.uint8array.js generated vendored Executable file
View File

@@ -0,0 +1,43 @@
#!/usr/bin/env mocha -R spec
var assert = require("assert");
var Bufferish = require("../lib/bufferish");
var msgpackJS = "../index";
var isBrowser = ("undefined" !== typeof window);
var msgpack = isBrowser && window.msgpack || require(msgpackJS);
var TITLE = __filename.replace(/^.*\//, "");
var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
describe(TITLE, function() {
it("{}", function() {
var encoded = msgpack.encode(1);
assert.ok(Buffer.isBuffer(encoded));
// assert.ok(!ArrayBuffer.isView(encoded));
});
var it_Uint8Array = HAS_UINT8ARRAY ? it : it.skip;
var codecopt = {uint8array: true};
it_Uint8Array(JSON.stringify(codecopt), function() {
var codec = msgpack.createCodec(codecopt);
assert.ok(codec);
var options = {codec: codec};
// small data
var encoded = msgpack.encode(1, options);
if (ArrayBuffer.isView) assert.ok(ArrayBuffer.isView(encoded));
assert.ok(Bufferish.isView(encoded));
assert.ok(!Buffer.isBuffer(encoded));
// bigger data
var big = new Buffer(8192); // 8KB
big[big.length - 1] = 99;
var source = [big, big, big, big, big, big, big, big]; // 64KB
encoded = msgpack.encode(source, options);
if (ArrayBuffer.isView) assert.ok(ArrayBuffer.isView(encoded));
assert.ok(Bufferish.isView(encoded));
assert.ok(!Buffer.isBuffer(encoded));
assert.equal(encoded[encoded.length - 1], 99); // last byte
});
});

59
node_modules/msgpack-lite/test/18.utf8.js generated vendored Executable file
View File

@@ -0,0 +1,59 @@
#!/usr/bin/env mocha -R spec
var assert = require("assert");
var msgpackJS = "../index";
var isBrowser = ("undefined" !== typeof window);
var msgpack = isBrowser && window.msgpack || require(msgpackJS);
var TITLE = __filename.replace(/^.*\//, "");
var OPTIONS = [{}, {safe: true}];
describe(TITLE, function() {
OPTIONS.forEach(function(options) {
var suffix = " " + JSON.stringify(options);
it("string (ASCII)" + suffix, function() {
var string = "a";
var array = [0xa1, 0x61];
var encoded = msgpack.encode(string, options);
var decoded = msgpack.decode(array, options);
assert.deepEqual(toArray(encoded), array);
assert.equal(decoded, string);
});
it("string (Greek)" + suffix, function() {
var string = "α";
var array = [0xa2, 0xce, 0xb1];
var encoded = msgpack.encode(string, options);
var decoded = msgpack.decode(array, options);
assert.deepEqual(toArray(encoded), array);
assert.equal(decoded, string);
});
it("string (Asian)" + suffix, function() {
var string = "亜";
var array = [0xa3, 0xe4, 0xba, 0x9c];
var encoded = msgpack.encode(string, options);
var decoded = msgpack.decode(array, options);
assert.deepEqual(toArray(encoded), array);
assert.equal(decoded, string);
});
// U+1F426 "🐦" bird
// http://unicode.org/emoji/charts/full-emoji-list.html#1f426
it("string (Emoji)" + suffix, function() {
var string = "\uD83D\uDC26"; // surrogate pair
var array_utf8 = [0xa4, 0xf0, 0x9f, 0x90, 0xa6]; // UTF-8
var array_cesu8 = [0xa6, 0xed, 0xa0, 0xbd, 0xed, 0xb0, 0xa6]; // CESU-8
var encoded = msgpack.encode(string, options);
var decoded_utf8 = msgpack.decode(array_utf8, options);
var decoded_cesu8 = msgpack.decode(array_cesu8, options);
assert.deepEqual(toArray(encoded), array_utf8);
assert.equal(decoded_utf8, string);
assert.equal(decoded_cesu8, string);
});
});
});
function toArray(buffer) {
return Array.prototype.slice.call(buffer);
}

220
node_modules/msgpack-lite/test/20.roundtrip.js generated vendored Executable file
View File

@@ -0,0 +1,220 @@
#!/usr/bin/env mocha -R spec
var assert = require("assert");
var msgpackJS = "../index";
var isBrowser = ("undefined" !== typeof window);
var msgpack = isBrowser && window.msgpack || require(msgpackJS);
var TITLE = __filename.replace(/^.*\//, "");
var STRING_ASCII = "a";
var STRING_GREEK = "α";
var STRING_ASIAN = "亜";
// 128K characters
for (var i = 0; i < 17; i++) {
STRING_ASCII = STRING_ASCII + STRING_ASCII;
STRING_GREEK = STRING_GREEK + STRING_GREEK;
STRING_ASIAN = STRING_ASIAN + STRING_ASIAN;
}
function pattern(min, max, offset) {
var array = [];
var check = {};
var val = min - 1;
while (val <= max) {
if (min <= val && !check[val]) array.push(val);
check[val++] = 1;
if (val <= max && !check[val]) array.push(val);
check[val++] = 1;
if (val <= max && !check[val]) array.push(val);
check[val--] = 1;
val = val ? val * 2 - 1 : 1;
}
return array;
}
var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
describe(TITLE, function() {
describe("Buffer", function() {
run_tests();
});
var describe_Uint8Array = HAS_UINT8ARRAY ? describe : describe.skip;
describe_Uint8Array("Uint8Array", function() {
run_tests({uint8array: true});
});
});
function run_tests(codecopt) {
var options;
if (codecopt) it(JSON.stringify(codecopt), function() {
var codec = msgpack.createCodec(codecopt);
assert.ok(codec);
options = {codec: codec};
});
it("null", function() {
[null, undefined].forEach(function(value) {
var encoded = msgpack.encode(value, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(decoded, value);
});
});
it("boolean", function() {
[true, false].forEach(function(value) {
var encoded = msgpack.encode(value, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(decoded, value);
});
});
it("positive int (small)", function() {
pattern(0, 0x40000000).forEach(function(value) {
value = value | 0; // integer
var encoded = msgpack.encode(value, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(decoded, value);
});
});
it("positive int (large)", function() {
pattern(0x40000000, 0xFFFFFFFF).forEach(function(value) {
var encoded = msgpack.encode(value, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(decoded, value);
});
});
it("negative int (small)", function() {
pattern(0, 0x40000000).forEach(function(value) {
value = -value | 0; // integer
var encoded = msgpack.encode(value, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(decoded, value);
});
});
it("negative int (large)", function() {
pattern(0x40000000, 0xFFFFFFFF).forEach(function(value) {
value = -value;
var encoded = msgpack.encode(value, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(decoded, value);
});
});
it("float", function() {
[1.1, 10.01, 100.001, 1000.0001, 10000.00001, 100000.000001, 1000000.0000001].forEach(function(value) {
var encoded = msgpack.encode(value, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(decoded, value);
});
});
it("string (ASCII)", function() {
this.timeout(30000);
pattern(0, 65537).forEach(function(length) {
var value = STRING_ASCII.substr(0, length);
var encoded = msgpack.encode(value, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(decoded, value);
});
});
it("string (GREEK)", function() {
this.timeout(30000);
pattern(0, 65537).forEach(function(length) {
var value = STRING_GREEK.substr(0, length);
var encoded = msgpack.encode(value, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(decoded, value);
});
});
it("string (ASIAN)", function() {
this.timeout(30000);
pattern(0, 65537).forEach(function(length) {
var value = STRING_ASIAN.substr(0, length);
var encoded = msgpack.encode(value, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(decoded, value);
});
});
it("array (small)", function() {
pattern(0, 257).forEach(function(length, idx) {
var value = new Array(length);
for (var i = 0; i < length; i++) {
value[i] = String.fromCharCode(i);
}
assert.equal(value.length, length);
var encoded = msgpack.encode(value, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(decoded.length, length);
assert.equal(decoded[0], value[0]);
assert.equal(decoded[length - 1], value[length - 1]);
});
});
it("array (large)", function() {
this.timeout(30000);
pattern(0, 65537).forEach(function(length) {
var value = new Array(length);
assert.equal(value.length, length);
var encoded = msgpack.encode(value, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(decoded.length, length);
assert.equal(decoded[0], value[0]);
assert.equal(decoded[length - 1], value[length - 1]);
});
});
it("object map (small)", function() {
pattern(0, 257).forEach(function(length) {
var value = {};
for (var i = 0; i < length; i++) {
var key = String.fromCharCode(i);
value[key] = length;
}
assert.equal(Object.keys(value).length, length);
var encoded = msgpack.encode(value, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(Object.keys(decoded).length, length);
assert.equal(decoded[0], value[0]);
assert.equal(decoded[length - 1], value[length - 1]);
});
});
it("object map (large)", function() {
this.timeout(30000);
pattern(65536, 65537).forEach(function(length) {
var value = {};
for (var i = 0; i < length; i++) {
value[i] = length;
}
assert.equal(Object.keys(value).length, length);
var encoded = msgpack.encode(value, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(Object.keys(decoded).length, length);
assert.equal(decoded[0], value[0]);
assert.equal(decoded[length - 1], value[length - 1]);
});
});
it("buffer", function() {
this.timeout(30000);
pattern(2, 65537).forEach(function(length, idx) {
var value = new Buffer(length);
value.fill(idx);
assert.equal(value.length, length);
var encoded = msgpack.encode(value, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(decoded.length, length);
assert.equal(decoded[0], value[0]);
assert.equal(decoded[length - 1], value[length - 1]);
});
});
}

85
node_modules/msgpack-lite/test/21.ext.js generated vendored Executable file
View File

@@ -0,0 +1,85 @@
#!/usr/bin/env mocha -R spec
/*jshint -W053 */
var assert = require("assert");
var msgpackJS = "../index";
var isBrowser = ("undefined" !== typeof window);
var msgpack = isBrowser && window.msgpack || require(msgpackJS);
var TITLE = __filename.replace(/^.*\//, "");
describe(TITLE, function() {
it("Boolean", function() {
[true, false].forEach(function(value) {
var source = new Boolean(value);
assert.equal(source - 0, value - 0);
var encoded = msgpack.encode(source);
assert.equal(encoded[0], 0xD4, "preset ext format failure. (128 means map format)"); // fixext 1
assert.equal(encoded[1], 0x0B); // Boolean
var decoded = msgpack.decode(encoded);
assert.equal(decoded - 0, source - 0);
assert.ok(decoded instanceof Boolean);
});
});
it("Date", function() {
var source = new Date();
var encoded = msgpack.encode(source);
assert.equal(encoded[0], 0xC7, "preset ext format failure. (128 means map format)"); // ext 8
assert.equal(encoded[1], 0x09); // 1+8
assert.equal(encoded[2], 0x0D); // Date
var decoded = msgpack.decode(encoded);
assert.equal(decoded - 0, source - 0);
assert.ok(decoded instanceof Date);
});
var ERROR_TYPES = ["Error", "EvalError", "RangeError", "ReferenceError", "SyntaxError", "TypeError", "URIError"];
ERROR_TYPES.forEach(function(name, idx) {
var Class = global[name];
it(name, function() {
var message = "foo:" + idx;
var source = new Class(message);
var encoded = msgpack.encode(source);
var decoded = msgpack.decode(encoded);
assert.equal(decoded + "", source + "");
assert.equal(decoded.name, name);
assert.equal(decoded.message, message);
assert.ok(decoded instanceof Class);
});
});
it("RegExp", function() {
var source = new RegExp("foo");
var encoded = msgpack.encode(source);
var decoded = msgpack.decode(encoded);
assert.equal(decoded + "", source + "");
assert.ok(decoded instanceof RegExp);
});
it("RegExp //g", function() {
var source = /foo\/bar/g;
var encoded = msgpack.encode(source);
var decoded = msgpack.decode(encoded);
assert.equal(decoded + "", source + "");
assert.ok(decoded instanceof RegExp);
});
it("Number", function() {
var source = new Number(123.456);
var encoded = msgpack.encode(source);
assert.equal(encoded[0], 0xC7); // ext 8
assert.equal(encoded[1], 0x09); // 1+8
assert.equal(encoded[2], 0x0F); // Number
var decoded = msgpack.decode(encoded);
assert.equal(decoded - 0, source - 0);
assert.ok(decoded instanceof Number);
});
it("String", function() {
var source = new String("qux");
var encoded = msgpack.encode(source);
var decoded = msgpack.decode(encoded);
assert.equal(decoded + "", source + "");
assert.ok(decoded instanceof String);
});
});

79
node_modules/msgpack-lite/test/22.typedarray.js generated vendored Executable file
View File

@@ -0,0 +1,79 @@
#!/usr/bin/env mocha -R spec
/*jshint -W053 */
var assert = require("assert");
var msgpackJS = "../index";
var isBrowser = ("undefined" !== typeof window);
var msgpack = isBrowser && window.msgpack || require(msgpackJS);
var TITLE = __filename.replace(/^.*\//, "");
var TYPED_ARRAY = {
"Int8Array": [0, 1, 2, 126, 127, -128, -127, -2, -1],
"Uint8Array": [0, 1, 2, 253, 254, 255],
"Uint8ClampedArray": [0, 1, 2, 253, 254, 255],
"Int16Array": [0, 1, 2, 32766, 32767, -32768, -32767, -2, -1],
"Uint16Array": [0, 1, 2, 65534, 65535],
"Int32Array": [0, 1, 2, 2147483646, 2147483647],
"Uint32Array": [0, 1, 2, 4294967294, 4294967295],
"Float32Array": [0, 1, 0.5, 0.25, -0.25, -0.5, -1],
"Float64Array": [0, 1, 0.5, 0.25, -0.25, -0.5, -1]
};
var ARRAY_BUFFER = {
"ArrayBuffer": [0, 1, 2, 253, 254, 255]
};
var DATA_VIEW = {
"DataView": [0, 1, 2, 253, 254, 255]
};
describe(TITLE, function() {
Object.keys(TYPED_ARRAY).forEach(function(name) {
var Class = global[name];
var skip = Class ? it : it.skip;
skip(name, function() {
var sample = TYPED_ARRAY[name];
var source = new Class(sample);
assert.ok(source instanceof Class);
assert.equal(source.length, sample.length);
var encoded = msgpack.encode(source);
var decoded = msgpack.decode(encoded);
var actual = Array.prototype.slice.call(decoded);
assert.deepEqual(actual, sample);
assert.ok(decoded instanceof Class);
});
});
Object.keys(ARRAY_BUFFER).forEach(function(name) {
var Class = global[name];
var skip = Class ? it : it.skip;
skip(name, function() {
var sample = ARRAY_BUFFER[name];
var source = (new Uint8Array(sample)).buffer;
assert.ok(source instanceof Class);
assert.equal(source.byteLength, sample.length);
var encoded = msgpack.encode(source);
var decoded = msgpack.decode(encoded);
var actual = Array.prototype.slice.call(new Uint8Array(decoded));
assert.deepEqual(actual, sample);
assert.ok(decoded instanceof Class);
});
});
Object.keys(DATA_VIEW).forEach(function(name) {
var Class = global[name];
var skip = Class ? it : it.skip;
skip(name, function() {
var sample = DATA_VIEW[name];
var source = new DataView((new Uint8Array(sample)).buffer);
assert.ok(source instanceof Class);
assert.equal(source.byteLength, sample.length);
var encoded = msgpack.encode(source);
var decoded = msgpack.decode(encoded);
var actual = Array.prototype.slice.call(new Uint8Array(decoded.buffer));
assert.deepEqual(actual, sample);
assert.ok(decoded instanceof Class);
});
});
});

79
node_modules/msgpack-lite/test/23.extbuffer.js generated vendored Executable file
View File

@@ -0,0 +1,79 @@
#!/usr/bin/env mocha -R spec
/*jshint -W053 */
var assert = require("assert");
var msgpackJS = "../index";
var isBrowser = ("undefined" !== typeof window);
var msgpack = isBrowser && window.msgpack || require(msgpackJS);
var TITLE = __filename.replace(/^.*\//, "");
var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
describe(TITLE, function() {
it("ExtBuffer (0x00)", function() {
testExtBuffer(0);
});
it("ExtBuffer (0x20-0xFF)", function() {
for (var i = 32; i < 256; i++) {
testExtBuffer(i);
}
});
it("ExtBuffer Array (0x20-0xFF)", function() {
for (var i = 32; i < 256; i++) {
testExtBufferArray(i);
}
});
function testExtBuffer(type) {
// fixext 8 -- 0xd7
var header = new Buffer([0xd7, type]);
var content = new Buffer(8);
for (var i = 0; i < 8; i++) {
content[i] = (type + i) & 0x7F;
}
var source = Buffer.concat([header, content]);
var decoded = msgpack.decode(source);
assert.equal(decoded.type, type);
assert.equal(decoded.buffer.length, content.length);
assert.deepEqual(toArray(decoded.buffer), toArray(content));
var encoded = msgpack.encode(decoded);
assert.deepEqual(toArray(encoded), toArray(source));
}
// Unpack and re-pack an array of extension types.
// Tests, among other things, that the right number of bytes are
// consumed with each ext type read.
function testExtBufferArray(type) {
function content(j) {
var x = j * type;
return Buffer([x & 0x7F, (x + 1) & 0x7F]);
}
// fixarray len 10
var arrayHeader = new Buffer([0x9a]);
var fullBuffer = arrayHeader;
for (var j = 0; j < 10; j++) {
// fixext 2 -- 0xd5
var header = new Buffer([0xd5, type]);
fullBuffer = Buffer.concat([fullBuffer, header, content(j)]);
}
var decoded = msgpack.decode(fullBuffer);
assert.equal(true, decoded instanceof Array);
assert.equal(decoded.length, 10);
for (j = 0; j < 10; j++) {
assert.equal(decoded[j].type, type);
assert.equal(decoded[j].buffer.length, 2);
assert.deepEqual(decoded[j].buffer, content(j));
}
var encoded = msgpack.encode(decoded);
assert.deepEqual(encoded, fullBuffer);
}
});
function toArray(array) {
if (HAS_UINT8ARRAY && array instanceof ArrayBuffer) array = new Uint8Array(array);
return Array.prototype.slice.call(array);
}

76
node_modules/msgpack-lite/test/24.int64.js generated vendored Executable file
View File

@@ -0,0 +1,76 @@
#!/usr/bin/env mocha -R spec
/*jshint -W053 */
var Int64Buffer = require("int64-buffer");
var Uint64BE = Int64Buffer.Uint64BE;
var Int64BE = Int64Buffer.Int64BE;
var assert = require("assert");
var msgpackJS = "../index";
var isBrowser = ("undefined" !== typeof window);
var msgpack = isBrowser && window.msgpack || require(msgpackJS);
var TITLE = __filename.replace(/^.*\//, "");
describe(TITLE, function() {
var options = {};
it("createCodec({int64: true})", function() {
var codec = msgpack.createCodec({int64: true});
assert.ok(codec);
options.codec = codec;
});
it("Uint64BE", function() {
[
0, 1, Math.pow(2, 16), Math.pow(2, 32), Math.pow(2, 48)
].forEach(function(value) {
var source = Uint64BE(value);
assert.equal(+source, value);
var encoded = msgpack.encode(source, options);
assert.equal(encoded[0], 0xcf);
assert.equal(encoded.length, 9);
var decoded = msgpack.decode(encoded, options);
assert.equal(+decoded, value);
});
[
"0", "1", "123456789abcdef0", "fedcba9876543210"
].forEach(function(value) {
var source = Uint64BE(value, 16);
assert.equal(source.toString(16), value);
var encoded = msgpack.encode(source, options);
assert.equal(encoded[0], 0xcf);
assert.equal(encoded.length, 9);
var decoded = msgpack.decode(encoded, options);
assert.equal(decoded.toString(16), value);
});
});
it("Int64BE", function() {
[
0, 1, Math.pow(2, 16), Math.pow(2, 32), Math.pow(2, 48),
-1, -Math.pow(2, 16), -Math.pow(2, 32), -Math.pow(2, 48)
].forEach(function(value) {
var source = Int64BE(value);
assert.equal(+source, value);
var encoded = msgpack.encode(source, options);
assert.equal(encoded[0], 0xd3);
assert.equal(encoded.length, 9);
var decoded = msgpack.decode(encoded, options);
assert.equal(+decoded, value);
});
[
"0", "1", "-1", "123456789abcdef0", "-123456789abcdef0"
].forEach(function(value) {
var source = Int64BE(value, 16);
assert.equal(source.toString(16), value);
var encoded = msgpack.encode(source, options);
assert.equal(encoded[0], 0xd3);
assert.equal(encoded.length, 9);
var decoded = msgpack.decode(encoded, options);
assert.equal(decoded.toString(16), value);
});
});
});

20
node_modules/msgpack-lite/test/26.es6.js generated vendored Executable file
View File

@@ -0,0 +1,20 @@
#!/usr/bin/env mocha -R spec
var assert = require("assert");
var msgpackJS = "../index";
var isBrowser = ("undefined" !== typeof window);
var msgpack = isBrowser && window.msgpack || require(msgpackJS);
var TITLE = __filename.replace(/^.*\//, "");
describe(TITLE, function() {
var skip = ("undefined" !== typeof Symbol) ? it : it.skip;
skip("Symbol", function() {
assert.deepEqual(toArray(msgpack.encode(Symbol("foo"))), [0xc0]);
});
});
function toArray(buffer) {
return Array.prototype.slice.call(buffer);
}

66
node_modules/msgpack-lite/test/27.usemap.js generated vendored Executable file
View File

@@ -0,0 +1,66 @@
#!/usr/bin/env mocha -R spec
var assert = require("assert");
var msgpackJS = "../index";
var isBrowser = ("undefined" !== typeof window);
var HAS_MAP = ("undefined" !== typeof Map);
var msgpack = isBrowser && window.msgpack || require(msgpackJS);
var TITLE = __filename.replace(/^.*\//, "");
function pattern(min, max, offset) {
var array = [];
var check = {};
var val = min - 1;
while (val <= max) {
if (min <= val && !check[val]) array.push(val);
check[val++] = 1;
if (val <= max && !check[val]) array.push(val);
check[val++] = 1;
if (val <= max && !check[val]) array.push(val);
check[val--] = 1;
val = val ? val * 2 - 1 : 1;
}
return array;
}
// Run these tests when Map is available
var describeSkip = HAS_MAP ? describe : describe.skip;
describeSkip(TITLE, function() {
it("Map (small)", function() {
pattern(0, 257).forEach(function(length) {
var value = new Map();
assert.equal(true, value instanceof Map);
for (var i = 0; i < length; i++) {
var key = String.fromCharCode(i);
value.set(key, length);
}
assert.equal(value.size, length);
var options = {codec: msgpack.createCodec({usemap: true})};
var encoded = msgpack.encode(value, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(true, decoded instanceof Map);
assert.equal(decoded.size, length);
assert.equal(decoded.get(String.fromCharCode(0)), value.get(String.fromCharCode(0)));
assert.equal(decoded.get(String.fromCharCode(length - 1)), value.get(String.fromCharCode(length - 1)));
});
});
it("Map (large)", function() {
this.timeout(30000);
pattern(65536, 65537).forEach(function(length) {
var value = new Map();
for (var i = 0; i < length; i++) {
value.set(i, length);
}
assert.equal(value.size, length);
var options = {codec: msgpack.createCodec({usemap: true})};
var encoded = msgpack.encode(value, options);
var decoded = msgpack.decode(encoded, options);
assert.equal(decoded.size, length);
assert.equal(decoded.get(0), value.get(0));
assert.equal(decoded.get(length - 1), value.get(length - 1));
});
});
});

119
node_modules/msgpack-lite/test/30.stream.js generated vendored Executable file
View File

@@ -0,0 +1,119 @@
#!/usr/bin/env mocha -R spec
var assert = require("assert");
var Stream = require("stream");
var concat = require("concat-stream");
var msgpack = require("../index");
var TITLE = __filename.replace(/^.*\//, "");
var example = require("./example.json");
var src = [
["foo"],
["bar"],
["baz"]
];
var encoded = [
msgpack.encode(src[0]),
msgpack.encode(src[1]),
msgpack.encode(src[2])
];
var encodeall = Buffer.concat(encoded);
describe(TITLE, function() {
it("msgpack.createEncodeStream()", function(done) {
var encoder = msgpack.createEncodeStream();
encoder.pipe(concat(onEnd));
encoder.write(src[0]);
encoder.write(src[1]);
encoder.write(src[2]);
encoder.end();
function onEnd(data) {
assert.deepEqual(data, encodeall);
done();
}
});
it("msgpack.createDecodeStream()", function(done) {
var count = 0;
var decoder = msgpack.createDecodeStream();
decoder.on("data", onData);
decoder.write(encoded[0]);
decoder.write(encoded[1]);
decoder.write(encoded[2]);
decoder.end();
function onData(data) {
assert.deepEqual(data, src[count++]);
if (count === 3) done();
}
});
it("pipe(encoder).pipe(decoder)", function(done) {
var count = 0;
var inputStream = new Stream.PassThrough({objectMode: true});
var encoder = msgpack.createEncodeStream();
var passThrough = new Stream.PassThrough();
var decoder = msgpack.createDecodeStream();
var outputStream = new Stream.PassThrough({objectMode: true});
inputStream.pipe(encoder).pipe(passThrough).pipe(decoder).pipe(outputStream);
outputStream.on("data", onData);
inputStream.write(src[0]);
inputStream.write(src[1]);
inputStream.write(src[2]);
inputStream.end();
function onData(data) {
assert.deepEqual(data, src[count++]);
if (count === 3) done();
}
});
it("pipe(decoder).pipe(encoder)", function(done) {
var inputStream = new Stream.PassThrough();
var decoder = msgpack.createDecodeStream();
var passThrough = new Stream.PassThrough({objectMode: true});
var encoder = msgpack.createEncodeStream();
inputStream.pipe(decoder).pipe(passThrough).pipe(encoder).pipe(concat(onEnd));
inputStream.write(encoded[0]);
inputStream.write(encoded[1]);
inputStream.write(encoded[2]);
inputStream.end();
function onEnd(data) {
assert.deepEqual(data, encodeall);
done();
}
});
it("write()", function(done) {
var count = 0;
var buf = msgpack.encode(example);
var decoder = msgpack.createDecodeStream();
decoder.on("data", onData);
for (var i = 0; i < 3; i++) {
Array.prototype.forEach.call(buf, each);
}
// decode stream should be closed
decoder.end();
// write a single byte into the decode stream
function each(x) {
decoder.write(Buffer([x]));
}
function onData(data) {
assert.deepEqual(data, example);
if (++count === 3) done();
}
});
});

58
node_modules/msgpack-lite/test/50.compat.js generated vendored Executable file
View File

@@ -0,0 +1,58 @@
#!/usr/bin/env mocha -R spec
var assert = require("assert");
var msgpack = require("../index");
var TITLE = __filename.replace(/^.*\//, "");
var data = require("./example.json");
describe(TITLE, function() {
test("msgpack", function(they) {
assert.deepEqual(they.unpack(msgpack.encode(data)), data);
assert.deepEqual(msgpack.decode(Buffer(they.pack(data))), data);
});
test("msgpack-js", function(they) {
assert.deepEqual(they.decode(msgpack.encode(data)), data);
assert.deepEqual(msgpack.decode(Buffer(they.encode(data))), data);
});
test("msgpack-js-v5", function(they) {
assert.deepEqual(they.decode(msgpack.encode(data)), data);
assert.deepEqual(msgpack.decode(Buffer(they.encode(data))), data);
});
test("msgpack5", function(they) {
they = they();
assert.deepEqual(they.decode(msgpack.encode(data)), data);
assert.deepEqual(msgpack.decode(Buffer(they.encode(data))), data);
});
test("notepack", function(they) {
assert.deepEqual(they.decode(msgpack.encode(data)), data);
assert.deepEqual(msgpack.decode(Buffer(they.encode(data))), data);
});
test("msgpack-unpack", function(they) {
assert.deepEqual(they(msgpack.encode(data)), data);
});
test("msgpack.codec", function(they) {
they = they.msgpack;
assert.deepEqual(they.unpack(msgpack.encode(data)), data);
assert.deepEqual(msgpack.decode(Buffer(they.pack(data))), data);
});
});
function test(name, func) {
var they;
var method = it;
try {
they = require(name);
} catch (e) {
method = it.skip;
name += ": " + e;
}
method(name, func.bind(null, they));
}

26
node_modules/msgpack-lite/test/61.encode-only.js generated vendored Executable file
View File

@@ -0,0 +1,26 @@
#!/usr/bin/env mocha -R spec
var assert = require("assert");
var encode = require("../lib/encode").encode;
var ExtBuffer = require("../lib/ext-buffer").ExtBuffer;
var TITLE = __filename.replace(/^.*\//, "");
describe(TITLE, function() {
it("encode", function() {
// int
assert.deepEqual(toArray(encode(1)), [1]);
// str
assert.deepEqual(toArray(encode("a")), [161, 97]);
// ExtBuffer
var ext = new ExtBuffer(new Buffer([1]), 127);
assert.ok(ext instanceof ExtBuffer);
assert.deepEqual(toArray(encode(ext)), [212, 127, 1]);
});
});
function toArray(buffer) {
return Array.prototype.slice.call(buffer);
}

23
node_modules/msgpack-lite/test/62.decode-only.js generated vendored Executable file
View File

@@ -0,0 +1,23 @@
#!/usr/bin/env mocha -R spec
var assert = require("assert");
var decode = require("../lib/decode").decode;
var ExtBuffer = require("../lib/ext-buffer").ExtBuffer;
var TITLE = __filename.replace(/^.*\//, "");
describe(TITLE, function() {
it("decode", function() {
// int
assert.equal(decode([1]), 1);
// str
assert.equal(decode([161, 97]), "a");
// ExtBuffer
var ext = decode(new Buffer([212, 127, 1]));
assert.ok(ext instanceof ExtBuffer);
assert.equal(ext.buffer[0], 1);
assert.equal(ext.type, 127);
});
});

77
node_modules/msgpack-lite/test/63.module-deps.js generated vendored Executable file
View File

@@ -0,0 +1,77 @@
#!/usr/bin/env mocha -R spec
var TITLE = __filename.replace(/^.*\//, "");
describe(TITLE, function() {
var mdeps;
var itSkip = it;
try {
mdeps = require("browserify/node_modules/module-deps");
} catch (e) {
itSkip = it.skip;
}
// index.js should not require stream modules
itSkip("index.js dependencies", function(next) {
var opt = {file: __dirname + "/../index.js"};
var list = [];
mdeps().on("data", onData).on("end", onEnd).end(opt);
function onData(data) {
list.push(data.file);
}
function onEnd() {
var hit = list.filter(check)[0];
next(hit && new Error(hit));
}
function check(value) {
return value.match(/stream/) && !value.match(/node_modules/);
}
});
// decode.js should not require encode|write modules
itSkip("decode.js dependencies", function(next) {
var opt = {file: __dirname + "/../lib/decode.js"};
var list = [];
mdeps().on("data", onData).on("end", onEnd).end(opt);
function onData(data) {
list.push(data.file);
}
function onEnd() {
var hit = list.filter(check)[0];
next(hit && new Error(hit));
}
function check(value) {
return value.match(/encode|write/) && !value.match(/node_modules/);
}
});
// encode.js should not require decode|read modules
itSkip("encode.js dependencies", function(next) {
var opt = {file: __dirname + "/../lib/encode.js"};
var list = [];
mdeps().on("data", onData).on("end", onEnd).end(opt);
function onData(data) {
list.push(data.file);
}
function onEnd() {
var hit = list.filter(check)[0];
next(hit && new Error(hit));
}
function check(value) {
return value.match(/decode|read/) && !value.match(/node_modules/);
}
});
});

52
node_modules/msgpack-lite/test/example.json generated vendored Normal file
View File

@@ -0,0 +1,52 @@
{
"int0": 0,
"int1": 1,
"int1-": -1,
"int8": 255,
"int8-": -255,
"int16": 256,
"int16-": -256,
"int32": 65536,
"int32-": -65536,
"nil": null,
"true": true,
"false": false,
"float": 0.5,
"float-": -0.5,
"string0": "",
"string1": "A",
"string4": "foobarbaz",
"string8": "Omnes viae Romam ducunt.",
"string16": "L’homme n’est qu’un roseau, le plus faible de la nature ; mais c’est un roseau pensant. Il ne faut pas que l’univers entier s’arme pour l’écraser : une vapeur, une goutte d’eau, suffit pour le tuer. Mais, quand l’univers l’écraserait, l’homme serait encore plus noble que ce qui le tue, puisqu’il sait qu’il meurt, et l’avantage que l’univers a sur lui, l’univers n’en sait rien. Toute notre dignité consiste donc en la pensée. C’est de là qu’il faut nous relever et non de l’espace et de la durée, que nous ne saurions remplir. Travaillons donc à bien penser : voilà le principe de la morale.",
"array0": [],
"array1": [
"foo"
],
"array8": [
1,
2,
4,
8,
16,
32,
64,
128,
256,
512,
1024,
2048,
4096,
8192,
16384,
32768,
65536,
131072,
262144,
524288,
1048576
],
"map0": {},
"map1": {
"foo": "bar"
}
}

4
node_modules/msgpack-lite/test/zuul/ie.html generated vendored Normal file
View File

@@ -0,0 +1,4 @@
<!--[if lte IE 9]>
<script src="https://cdnjs.cloudflare.com/ajax/libs/es5-shim/4.1.10/es5-shim.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/json3/3.3.2/json3.min.js"></script>
<![endif]-->