arnaudne/lsp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Arnaud Nelissen
2021-07-16 10:18:13 +02:00
commit 3af7ddab06
5894 changed files with 590836 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
node_modules/cbor/LICENSE.md generated vendored Normal file
View File

@@ -0,0 +1,20 @@
The MIT License (MIT)
Copyright (c) 2014 Joe Hildebrand
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.

216
node_modules/cbor/README.md generated vendored Normal file
View File

@@ -0,0 +1,216 @@
cbor
====
Encode and parse data in the Concise Binary Object Representation (CBOR) data format ([RFC7049](http://tools.ietf.org/html/rfc7049)).
Installation:
------------
```bash
$ npm install --save cbor
```
**NOTE**
This package now requires node.js 8.3 or higher. It will work on node.js 6, in
a less-tested, less-featureful way. Please start upgrading if it is possible
for you.
Documentation:
-------------
See the full API [documentation](http://hildjj.github.io/node-cbor/).
For a command-line interface, see [cbor-cli](https://github.com/hildjj/node-cbor/tree/master/cli).
Example:
```javascript
var cbor = require('cbor');
var assert = require('assert');
var encoded = cbor.encode(true); // returns <Buffer f5>
cbor.decodeFirst(encoded, function(error, obj) {
// error != null if there was an error
// obj is the unpacked object
assert.ok(obj === true);
});
// Use integers as keys?
var m = new Map();
m.set(1, 2);
encoded = cbor.encode(m); // <Buffer a1 01 02>
```
Allows streaming as well:
```javascript
var cbor = require('cbor');
var fs = require('fs');
var d = new cbor.Decoder();
d.on('data', function(obj){
console.log(obj);
});
var s = fs.createReadStream('foo');
s.pipe(d);
var d2 = new cbor.Decoder({input: '00', encoding: 'hex'});
d.on('data', function(obj){
console.log(obj);
});
```
There is also support for synchronous decodes:
```javascript
try {
console.log(cbor.decodeFirstSync('02')); // 2
console.log(cbor.decodeAllSync('0202')); // [2, 2]
} catch (e) {
// throws on invalid input
}
```
The sync encoding and decoding are exported as a
[leveldb encoding](https://github.com/Level/levelup#custom_encodings), as
`cbor.leveldb`.
## highWaterMark
The synchronous routines for encoding and decoding will have problems with
objects that are larger than 16kB, which the default buffer size for Node
streams. There are a few ways to fix this:
1) pass in a `highWaterMark` option with the value of the largest buffer size you think you will need:
```javascript
cbor.encodeOne(Buffer.alloc(40000), {highWaterMark: 65535})
```
2) use stream mode. Catch the `data`, `finish`, and `error` events. Make sure to call `end()` when you're done.
```javascript
const enc = new cbor.Encoder()
enc.on('data', buf => /* send the data somewhere */)
enc.on('error', console.error)
enc.on('finish', () => /* tell the consumer we are finished */)
enc.end(['foo', 1, false])
```
3) use `encodeAsync()`, which uses the approach from approach 2 to return a memory-inefficient promise for a Buffer.
## Supported types
The following types are supported for encoding:
* boolean
* number (including -0, NaN, and ±Infinity)
* string
* Array, Set (encoded as Array)
* Object (including null), Map
* undefined
* Buffer
* Date,
* RegExp
* url.URL
* BigInt (If your JS version supports them)
* [bignumber](https://github.com/MikeMcl/bignumber.js)
Decoding supports the above types, including the following CBOR tag numbers:
| Tag | Generated Type |
|-----|----------------|
| 0 | Date |
| 1 | Date |
| 2 | bignumber |
| 3 | bignumber |
| 4 | bignumber |
| 5 | bignumber |
| 32 | url.URL |
| 35 | RegExp |
## Adding new Encoders
There are several ways to add a new encoder:
### `encodeCBOR` method
This is the easiest approach, if you can modify the class being encoded. Add an
`encodeCBOR` method to your class, which takes a single parameter of the encoder
currently being used. Your method should return `true` on success, else `false`.
Your method may call `encoder.push(buffer)` or `encoder.pushAny(any)` as needed.
For example:
```javascript
class Foo {
constructor () {
this.one = 1
this.two = 2
}
encodeCBOR (encoder) {
const tagged = new Tagged(64000, [this.one, this.two])
return encoder.pushAny(tagged)
}
}
```
You can also modify an existing type by monkey-patching an `encodeCBOR` function
onto its prototype, but this isn't recommended.
### `addSemanticType`
Sometimes, you want to support an existing type without modification to that
type. In this case, call `addSemanticType(type, encodeFunction)` on an existing
`Encoder` instance. The `encodeFunction` takes an encoder and an object to
encode, for example:
```javascript
class Bar {
constructor () {
this.three = 3
}
}
const enc = new Encoder()
enc.addSemanticType(Bar, (encoder, b) => {
encoder.pushAny(b.three)
})
```
## Adding new decoders
Most of the time, you will want to add support for decoding a new tag type. If
the Decoder class encounters a tag it doesn't support, it will generate a `Tagged`
instance that you can handle or ignore as needed. To have a specific type
generated instead, pass a `tags` option to the `Decoder`'s constructor, consisting
of an object with tag number keys and function values. The function will be
passed the decoded value associated with the tag, and should return the decoded
value. For the `Foo` example above, this might look like:
```javascript
const d = new Decoder({tags: { 64000: (val) => {
// check val to make sure it's an Array as expected, etc.
const foo = new Foo()
foo.one = val[0]
foo.two = val[1]
return foo
}}})
```
Developers
----------
The tests for this package use a set of test vectors from RFC 7049 appendix A by importing a machine readable version of them from https://github.com/cbor/test-vectors. For these tests to work, you will need to use the command `git submodule update --init` after cloning or pulling this code. See https://gist.github.com/gitaarik/8735255#file-git_submodules-md for more information.
Get a list of build steps with `npm run`. I use `npm run dev`, which rebuilds,
runs tests, and refreshes a browser window with coverage metrics every time I
save a `.js` file. If you don't want to run the fuzz tests every time, set
a `NO_GARBAGE` environment variable:
```
env NO_GARBAGE=1 npm run dev
```
[![Build Status](https://api.travis-ci.org/hildjj/node-cbor.svg)](https://travis-ci.org/hildjj/node-cbor)
[![Coverage Status](https://coveralls.io/repos/hildjj/node-cbor/badge.svg?branch=master)](https://coveralls.io/r/hildjj/node-cbor?branch=master)
[![Dependency Status](https://david-dm.org/hildjj/node-cbor.svg)](https://david-dm.org/hildjj/node-cbor)

30
node_modules/cbor/lib/cbor.js generated vendored Normal file
View File

@@ -0,0 +1,30 @@
'use strict'
exports.Commented = require('./commented')
exports.Diagnose = require('./diagnose')
exports.Decoder = require('./decoder')
exports.Encoder = require('./encoder')
exports.Simple = require('./simple')
exports.Tagged = require('./tagged')
exports.Map = require('./map')
exports.comment = exports.Commented.comment
exports.decodeAll = exports.Decoder.decodeAll
exports.decodeFirst = exports.Decoder.decodeFirst
exports.decodeAllSync = exports.Decoder.decodeAllSync
exports.decodeFirstSync = exports.Decoder.decodeFirstSync
exports.diagnose = exports.Diagnose.diagnose
exports.encode = exports.Encoder.encode
exports.encodeCanonical = exports.Encoder.encodeCanonical
exports.encodeOne = exports.Encoder.encodeOne
exports.encodeAsync = exports.Encoder.encodeAsync
exports.decode = exports.Decoder.decodeFirstSync
exports.leveldb = {
decode: exports.Decoder.decodeAllSync,
encode: exports.Encoder.encode,
buffer: true,
name: 'cbor'
}
exports.hasBigInt = require('./utils').hasBigInt

345
node_modules/cbor/lib/commented.js generated vendored Normal file
View File

@@ -0,0 +1,345 @@
'use strict'
const stream = require('stream')
const util = require('util')
const utils = require('./utils')
const Simple = require('./simple')
const Decoder = require('./decoder')
const constants = require('./constants')
const bignumber = require('bignumber.js').BigNumber
const NoFilter = require('nofilter')
const MT = constants.MT
const NUMBYTES = constants.NUMBYTES
const SYMS = constants.SYMS
function plural(c) {
if (c > 1) {
return 's'
} else {
return ''
}
}
/**
* Generate the expanded format of RFC 7049, section 2.2.1
*
* @extends {stream.Transform}
*/
class Commented extends stream.Transform {
/**
* Create a CBOR commenter.
*
* @param {object} [options={}] - Stream options
* @param {number} [options.max_depth=10] - how many times to indent
* the dashes
*/
constructor(options) {
const opts = Object.assign({
max_depth: 10
}, options, {
readableObjectMode: false,
writableObjectMode: false
})
const max_depth = opts.max_depth
delete opts.max_depth
super(opts)
this.depth = 1
this.max_depth = max_depth
this.all = new NoFilter()
this.parser = new Decoder(opts)
this.parser.on('value', this._on_value.bind(this))
this.parser.on('start', this._on_start.bind(this))
this.parser.on('start-string', this._on_start_string.bind(this))
this.parser.on('stop', this._on_stop.bind(this))
this.parser.on('more-bytes', this._on_more.bind(this))
this.parser.on('error', this._on_error.bind(this))
this.parser.on('data', this._on_data.bind(this))
this.parser.bs.on('read', this._on_read.bind(this))
}
/**
* @private
*/
_transform(fresh, encoding, cb) {
this.parser.write(fresh, encoding, cb)
}
/**
* @private
*/
_flush(cb) {
// TODO: find the test that covers this, and look at the return value
return this.parser._flush(cb)
}
/**
* @callback commentCallback
* @param {Error} [error] - if one was generated
* @param {string} [commented] - the comment string
*/
/**
* @typedef CommentOptions
* @property {number} [max_depth=10] how many times to indent the dashes
* @property {string} [encoding='hex'] encoding of the input
*/
/**
* Comment on an input Buffer or string, creating a string passed to the
* callback. If callback not specified, a promise is returned.
*
* @static
* @param {string|Buffer} input
* @param {CommentOptions|commentCallback|string} [options] or callback
* @param {commentCallback=} cb
* @returns {Promise} if cb not specified
*/
static comment(input, options, cb) {
if (input == null) {
throw new Error('input required')
}
let encoding = (typeof input === 'string') ? 'hex' : void 0
let max_depth = 10
switch (typeof options) {
case 'function':
cb = options
break
case 'string':
encoding = options
break
case 'number':
max_depth = options
break
case 'object':
const ref1 = options.encoding
const ref2 = options.max_depth
encoding = (ref1 != null) ? ref1 : encoding
max_depth = (ref2 != null) ? ref2 : max_depth
break
case 'undefined':
break
default:
throw new Error('Unknown option type')
}
const bs = new NoFilter()
const d = new Commented({
max_depth
})
let p = null
if (typeof cb === 'function') {
d.on('end', () => {
cb(null, bs.toString('utf8'))
})
d.on('error', cb)
} else {
p = new Promise((resolve, reject) => {
d.on('end', () => {
resolve(bs.toString('utf8'))
})
return d.on('error', reject)
})
}
d.pipe(bs)
d.end(input, encoding)
return p
}
/**
* @private
*/
_on_error(er) {
return this.push('ERROR: ') &&
this.push(er.toString()) &&
this.push('\n')
}
/**
* @private
*/
_on_read(buf) {
this.all.write(buf)
const hex = buf.toString('hex')
this.push(new Array(this.depth + 1).join(' '))
this.push(hex)
let ind = (this.max_depth - this.depth) * 2
ind -= hex.length
if (ind < 1) {
ind = 1
}
this.push(new Array(ind + 1).join(' '))
return this.push('-- ')
}
/**
* @private
*/
_on_more(mt, len, parent_mt, pos) {
this.depth++
let desc = ''
switch (mt) {
case MT.POS_INT:
desc = 'Positive number,'
break
case MT.NEG_INT:
desc = 'Negative number,'
break
case MT.ARRAY:
desc = 'Array, length'
break
case MT.MAP:
desc = 'Map, count'
break
case MT.BYTE_STRING:
desc = 'Bytes, length'
break
case MT.UTF8_STRING:
desc = 'String, length'
break
case MT.SIMPLE_FLOAT:
if (len === 1) {
desc = 'Simple value,'
} else {
desc = 'Float,'
}
break
}
return this.push(desc + ' next ' + len + ' byte' + (plural(len)) + '\n')
}
/**
* @private
*/
_on_start_string(mt, tag, parent_mt, pos) {
this.depth++
let desc = ''
switch (mt) {
case MT.BYTE_STRING:
desc = 'Bytes, length: ' + tag
break
case MT.UTF8_STRING:
desc = 'String, length: ' + (tag.toString())
break
}
return this.push(desc + '\n')
}
/**
* @private
*/
_on_start(mt, tag, parent_mt, pos) {
this.depth++
if (tag !== SYMS.BREAK) {
switch (parent_mt) {
case MT.ARRAY:
this.push(`[${pos}], `)
break
case MT.MAP:
if (pos % 2) {
this.push(`{Val:${Math.floor(pos / 2)}}, `)
} else {
this.push(`{Key:${Math.floor(pos / 2)}}, `)
}
break
}
}
switch (mt) {
case MT.TAG:
this.push(`Tag #${tag}`)
break
case MT.ARRAY:
if (tag === SYMS.STREAM) {
this.push('Array (streaming)')
} else {
this.push(`Array, ${tag} item${plural(tag)}`)
}
break
case MT.MAP:
if (tag === SYMS.STREAM) {
this.push('Map (streaming)')
} else {
this.push(`Map, ${tag} pair${plural(tag)}`)
}
break
case MT.BYTE_STRING:
this.push('Bytes (streaming)')
break
case MT.UTF8_STRING:
this.push('String (streaming)')
break
}
return this.push('\n')
}
/**
* @private
*/
_on_stop(mt) {
return this.depth--
}
/**
* @private
*/
_on_value(val, parent_mt, pos, ai) {
if (val !== SYMS.BREAK) {
switch (parent_mt) {
case MT.ARRAY:
this.push(`[${pos}], `)
break
case MT.MAP:
if (pos % 2) {
this.push(`{Val:${Math.floor(pos / 2)}}, `)
} else {
this.push(`{Key:${Math.floor(pos / 2)}}, `)
}
break
}
}
if (val === SYMS.BREAK) {
this.push('BREAK\n')
} else if (val === SYMS.NULL) {
this.push('null\n')
} else if (val === SYMS.UNDEFINED) {
this.push('undefined\n')
} else if (typeof val === 'string') {
this.depth--
if (val.length > 0 ) {
this.push(JSON.stringify(val))
this.push('\n')
}
} else if (Buffer.isBuffer(val)) {
this.depth--
if (val.length > 0) {
this.push(val.toString('hex'))
this.push('\n')
}
} else if (val instanceof bignumber) {
this.push(val.toString())
this.push('\n')
} else {
this.push(util.inspect(val))
this.push('\n')
}
switch (ai) {
case NUMBYTES.ONE:
case NUMBYTES.TWO:
case NUMBYTES.FOUR:
case NUMBYTES.EIGHT:
this.depth--
}
}
/**
* @private
*/
_on_data() {
this.push('0x')
this.push(this.all.read().toString('hex'))
return this.push('\n')
}
}
module.exports = Commented

75
node_modules/cbor/lib/constants.js generated vendored Normal file
View File

@@ -0,0 +1,75 @@
'use strict'
const bignumber = require('bignumber.js').BigNumber
exports.MT = {
POS_INT: 0,
NEG_INT: 1,
BYTE_STRING: 2,
UTF8_STRING: 3,
ARRAY: 4,
MAP: 5,
TAG: 6,
SIMPLE_FLOAT: 7
}
exports.TAG = {
DATE_STRING: 0,
DATE_EPOCH: 1,
POS_BIGINT: 2,
NEG_BIGINT: 3,
DECIMAL_FRAC: 4,
BIGFLOAT: 5,
BASE64URL_EXPECTED: 21,
BASE64_EXPECTED: 22,
BASE16_EXPECTED: 23,
CBOR: 24,
URI: 32,
BASE64URL: 33,
BASE64: 34,
REGEXP: 35,
MIME: 36
}
exports.NUMBYTES = {
ZERO: 0,
ONE: 24,
TWO: 25,
FOUR: 26,
EIGHT: 27,
INDEFINITE: 31
}
exports.SIMPLE = {
FALSE: 20,
TRUE: 21,
NULL: 22,
UNDEFINED: 23
}
exports.SYMS = {
NULL: Symbol('null'),
UNDEFINED: Symbol('undef'),
PARENT: Symbol('parent'),
BREAK: Symbol('break'),
STREAM: Symbol('stream')
}
exports.SHIFT32 = 0x100000000
exports.BI = {
MINUS_ONE: -1,
MAXINT32: 0xffffffff,
MAXINT64: '0xffffffffffffffff',
SHIFT32: exports.SHIFT32
}
const MINUS_ONE = new bignumber(-1)
exports.BN = {
MINUS_ONE,
NEG_MAX: MINUS_ONE.minus(
new bignumber(Number.MAX_SAFE_INTEGER.toString(16), 16)),
MAXINT: new bignumber('0x20000000000000'),
MAXINT32: new bignumber(0xffffffff),
MAXINT64: new bignumber('0xffffffffffffffff'),
SHIFT32: new bignumber(exports.SHIFT32)
}

574
node_modules/cbor/lib/decoder.js generated vendored Normal file
View File

@@ -0,0 +1,574 @@
'use strict'
const stream = require('stream')
const BinaryParseStream = require('../vendor/binary-parse-stream')
const Tagged = require('./tagged')
const Simple = require('./simple')
const utils = require('./utils')
const bignumber = require('bignumber.js').BigNumber
const NoFilter = require('nofilter')
const constants = require('./constants')
// Do not fix this if you want to support node v4
const MT = constants.MT
const NUMBYTES = constants.NUMBYTES
const SIMPLE = constants.SIMPLE
const SYMS = constants.SYMS
const BI = utils.bigIntize(constants.BI)
const BN = constants.BN
const COUNT = Symbol('count')
const PENDING_KEY = Symbol('pending_key')
const MAJOR = Symbol('major type')
const ERROR = Symbol('error')
const NOT_FOUND = Symbol('not found')
function parentArray(parent, typ, count) {
const a = []
a[COUNT] = count
a[SYMS.PARENT] = parent
a[MAJOR] = typ
return a
}
function parentBufferStream(parent, typ) {
const b = new NoFilter()
b[COUNT] = -1
b[SYMS.PARENT] = parent
b[MAJOR] = typ
return b
}
/**
* @param {Buffer} v
* @private
*/
function _tag_2(v) {
return utils.bufferToBigInt(v)
}
/**
* @param {BigInt} v
* @private
*/
function _tag_3(v) {
// avoid syntax error on old runtimes
return BI.MINUS_ONE - utils.bufferToBigInt(v)
}
/**
* Decode a stream of CBOR bytes by transforming them into equivalent
* JavaScript data. Because of the limitations of Node object streams,
* special symbols are emitted instead of NULL or UNDEFINED. Fix those
* up by calling {@link Decoder.nullcheck}.
*
* @extends {BinaryParseStream}
*/
class Decoder extends BinaryParseStream {
/**
* Create a parsing stream.
*
* @param {object} [options={}]
* @param {number} [options.max_depth=-1] - the maximum depth to parse.
* Use -1 for "until you run out of memory". Set this to a finite
* positive number for un-trusted inputs. Most standard inputs won't nest
* more than 100 or so levels; I've tested into the millions before
* running out of memory.
* @param {object} [options.tags] - mapping from tag number to function(v),
* where v is the decoded value that comes after the tag, and where the
* function returns the correctly-created value for that tag.
* @param {boolean} [options.bigint=false] generate JavaScript BigInt's
* instead of BigNumbers, when possible. TODO: when BigInt's are
* more prevalent, change this to default to the value of cbor.hasBigInt.
*/
constructor(options) {
options = options || {}
const tags = options.tags
delete options.tags
const max_depth = (options.max_depth != null) ? options.max_depth : -1
delete options.max_depth
const bigI = utils.hasBigInt ? (!!options.bigint) : false
delete options.bigint
super(options)
this.running = true
this.max_depth = max_depth
this.tags = tags
if (bigI) {
if (this.tags == null) {
this.tags = {}
}
if (this.tags[2] == null) {
this.tags[2] = _tag_2
}
if (this.tags[3] == null) {
this.tags[3] = _tag_3
}
}
}
/**
* Check the given value for a symbol encoding a NULL or UNDEFINED value in
* the CBOR stream.
*
* @static
* @param {any} val - the value to check
* @returns {any} the corrected value
*
* @example
* myDecoder.on('data', function(val) {
* val = Decoder.nullcheck(val);
* ...
* });
*/
static nullcheck(val) {
switch (val) {
case SYMS.NULL:
return null
case SYMS.UNDEFINED:
return undefined
case NOT_FOUND:
throw new Error('Value not found')
default:
return val
}
}
/**
* @typedef DecodeOptions
* @property {string} [encoding='hex'] - The encoding of the input.
* Ignored if input is a Buffer.
*/
/**
* Decode the first CBOR item in the input, synchronously. This will throw an
* exception if the input is not valid CBOR.
*
* @static
* @param {string|Buffer|stream.Readable} input
* @param {DecodeOptions|string} [options] Options
* @returns {any} - the decoded value
*/
static decodeFirstSync(input, options) {
options = options || { encoding: 'hex' }
let opts = {}
let encod
switch (typeof options) {
case 'string':
encod = options
break
case 'object':
opts = utils.extend({}, options)
encod = opts.encoding
delete opts.encoding
break
}
const c = new Decoder(opts)
const s = (input instanceof stream.Readable) ? input : new NoFilter(
input,
encod != null ? encod : utils.guessEncoding(input))
// for/of doesn't work when you need to call next() with a value
// generator created by parser will be "done" after each CBOR entity
// parser will yield numbers of bytes that it wants
const parser = c._parse()
let state = parser.next()
while (!state.done) {
const b = s.read(state.value)
if ((b == null) || (b.length !== state.value)) {
throw new Error('Insufficient data')
}
state = parser.next(b)
}
const val = Decoder.nullcheck(state.value)
if (s.length > 0) {
const nextByte = s.read(1)
s.unshift(nextByte)
const er = new Error(
'Unexpected data: 0x' + nextByte[0].toString(16))
er.value = val
throw er
}
return val
}
/**
* Decode all of the CBOR items in the input into an array. This will throw
* an exception if the input is not valid CBOR; a zero-length input will
* return an empty array.
*
* @static
* @param {string|Buffer|stream.Readable} input
* @param {DecodeOptions|string} [options] Options or encoding string
* @returns {Array} - Array of all found items
*/
static decodeAllSync(input, options) {
options = options || { encoding: 'hex' }
let opts = {}
let encod
switch (typeof options) {
case 'string':
encod = options
break
case 'object':
opts = utils.extend({}, options)
encod = opts.encoding
delete opts.encoding
}
const c = new Decoder(opts)
const s = (input instanceof stream.Readable) ? input : new NoFilter(
input,
encod != null ? encod : utils.guessEncoding(input))
const res = []
while (s.length > 0) {
const parser = c._parse()
let state = parser.next()
while (!state.done) {
const b = s.read(state.value)
if ((b == null) || (b.length !== state.value)) {
throw new Error('Insufficient data')
}
state = parser.next(b)
}
res.push(Decoder.nullcheck(state.value))
}
return res
}
/**
* @callback decodeCallback
* @param {Error} [error] - if one was generated
* @param {any} [value] - the decoded value
*/
/**
* Decode the first CBOR item in the input. This will error if there are more
* bytes left over at the end, and optionally if there were no valid CBOR
* bytes in the input. Emits the {Decoder.NOT_FOUND} Symbol in the callback
* if no data was found and the `required` option is false.
*
* @static
* @param {string|Buffer} input - the input to parse
* @param {DecodeOptions|decodeCallback|string} [options] - options
* @param {decodeCallback} [cb] callback
* @returns {Promise<any>} returned even if callback is specified
*/
static decodeFirst(input, options, cb) {
let opts = {}
let required = false
let encod = 'hex'
switch (typeof options) {
case 'function':
cb = options
encod = utils.guessEncoding(input)
break
case 'string':
encod = options
break
case 'object':
opts = utils.extend({}, options)
encod = (opts.encoding != null) ?
opts.encoding : utils.guessEncoding(input)
delete opts.encoding
required = (opts.required != null) ? opts.required : false
delete opts.required
}
const c = new Decoder(opts)
let v = NOT_FOUND
const p = new Promise((resolve, reject) => {
c.on('data', (val) => {
v = Decoder.nullcheck(val)
c.close()
})
c.once('error', (er) => {
if (v !== NOT_FOUND) {
er.value = v
}
v = ERROR
c.close()
return reject(er)
})
c.once('end', () => {
switch (v) {
case NOT_FOUND:
if (required) {
return reject(new Error('No CBOR found'))
} else {
return resolve(v)
}
case ERROR:
return void 0
default:
return resolve(v)
}
})
})
if (typeof cb === 'function') {
p.then(v => cb(null, v), cb)
}
c.end(input, encod)
return p
}
/**
* @callback decodeAllCallback
* @param {Error} error - if one was generated
* @param {Array} value - all of the decoded values, wrapped in an Array
*/
/**
* Decode all of the CBOR items in the input. This will error if there are
* more bytes left over at the end.
*
* @static
* @param {(string|Buffer)} input - the input to parse
* @param {(string|Object)} options - Decoding options.
* If string, the input encoding.
* @param {decodeAllCallback} cb callback
* @returns {Promise<Array>} even if callback is specified
*/
static decodeAll(input, options, cb) {
let opts = {}
let encod = 'hex'
switch (typeof options) {
case 'function':
cb = options
encod = utils.guessEncoding(input)
break
case 'string':
encod = options
break
case 'object':
opts = utils.extend({}, options)
encod = (opts.encoding != null) ?
opts.encoding : utils.guessEncoding(input)
delete opts.encoding
}
const c = new Decoder(opts)
const vals = []
c.on('data', (val) => {
return vals.push(Decoder.nullcheck(val))
})
const p = new Promise((resolve, reject) => {
c.on('error', reject)
c.on('end', () => resolve(vals))
})
if (typeof cb === 'function') {
p.then(v => cb(null, v), cb)
}
c.end(input, encod)
return p
}
/**
* Stop processing
*/
close() {
this.running = false
this.__fresh = true
}
*_parse() {
let parent = null
let depth = 0
let val = null
while (true) {
if ((this.max_depth >= 0) && (depth > this.max_depth)) {
throw new Error('Maximum depth ' + this.max_depth + ' exceeded')
}
const octet = (yield 1)[0]
if (!this.running) {
throw new Error('Unexpected data: 0x' + (octet.toString(16)))
}
const mt = octet >> 5
const ai = octet & 0x1f
const parent_major = (parent != null) ? parent[MAJOR] : undefined
const parent_length = (parent != null) ? parent.length : undefined
switch (ai) {
case NUMBYTES.ONE:
this.emit('more-bytes', mt, 1, parent_major, parent_length)
val = (yield 1)[0]
break
case NUMBYTES.TWO:
case NUMBYTES.FOUR:
case NUMBYTES.EIGHT:
const numbytes = 1 << (ai - 24)
this.emit('more-bytes', mt, numbytes, parent_major, parent_length)
const buf = yield numbytes
val = (mt === MT.SIMPLE_FLOAT) ? buf : utils.parseCBORint(ai, buf)
break
case 28:
case 29:
case 30:
this.running = false
throw new Error('Additional info not implemented: ' + ai)
case NUMBYTES.INDEFINITE:
switch (mt) {
case MT.POS_INT:
case MT.NEG_INT:
case MT.TAG:
throw new Error(`Invalid indefinite encoding for MT ${mt}`)
}
val = -1
break
default:
val = ai
}
switch (mt) {
case MT.POS_INT:
// val already decoded
break
case MT.NEG_INT:
if (val === Number.MAX_SAFE_INTEGER) {
val = BN.NEG_MAX
} else if (val instanceof bignumber) {
val = BN.MINUS_ONE.minus(val)
} else {
val = -1 - val
}
break
case MT.BYTE_STRING:
case MT.UTF8_STRING:
switch (val) {
case 0:
this.emit('start-string', mt, val, parent_major, parent_length)
val = (mt === MT.BYTE_STRING) ? Buffer.allocUnsafe(0) : ''
break
case -1:
this.emit('start', mt, SYMS.STREAM, parent_major, parent_length)
parent = parentBufferStream(parent, mt)
depth++
continue
default:
this.emit('start-string', mt, val, parent_major, parent_length)
val = yield val
if (mt === MT.UTF8_STRING) {
val = utils.utf8(val)
}
}
break
case MT.ARRAY:
case MT.MAP:
switch (val) {
case 0:
val = (mt === MT.MAP) ? {} : []
break
case -1:
this.emit('start', mt, SYMS.STREAM, parent_major, parent_length)
parent = parentArray(parent, mt, -1)
depth++
continue
default:
this.emit('start', mt, val, parent_major, parent_length)
parent = parentArray(parent, mt, val * (mt - 3))
depth++
continue
}
break
case MT.TAG:
this.emit('start', mt, val, parent_major, parent_length)
parent = parentArray(parent, mt, 1)
parent.push(val)
depth++
continue
case MT.SIMPLE_FLOAT:
if (typeof val === 'number') {
if ((ai === NUMBYTES.ONE) && (val < 32)) {
throw new Error(
`Invalid two-byte encoding of simple value ${val}`
)
}
const hasParent = (parent != null)
val = Simple.decode(
val,
hasParent,
hasParent && (parent[COUNT] < 0))
} else {
val = utils.parseCBORfloat(val)
}
}
this.emit('value', val, parent_major, parent_length, ai)
let again = false
while (parent != null) {
switch (false) {
case val !== SYMS.BREAK:
parent[COUNT] = 1
break
case !Array.isArray(parent):
parent.push(val)
break
case !(parent instanceof NoFilter):
const pm = parent[MAJOR]
if ((pm != null) && (pm !== mt)) {
this.running = false
throw new Error('Invalid major type in indefinite encoding')
}
parent.write(val)
}
if ((--parent[COUNT]) !== 0) {
again = true
break
}
--depth
delete parent[COUNT]
this.emit('stop', parent[MAJOR])
if (Array.isArray(parent)) {
switch (parent[MAJOR]) {
case MT.ARRAY:
val = parent
break
case MT.MAP:
let allstrings = true
if ((parent.length % 2) !== 0) {
throw new Error('Invalid map length: ' + parent.length)
}
for (let i = 0, len = parent.length; i < len; i += 2) {
if (typeof parent[i] !== 'string') {
allstrings = false
break
}
}
if (allstrings) {
val = {}
for (let i = 0, len = parent.length; i < len; i += 2) {
val[parent[i]] = parent[i + 1]
}
} else {
val = new Map
for (let i = 0, len = parent.length; i < len; i += 2) {
val.set(parent[i], parent[i + 1])
}
}
break
case MT.TAG:
const t = new Tagged(parent[0], parent[1])
val = t.convert(this.tags)
break
}
} else if (parent instanceof NoFilter) {
switch (parent[MAJOR]) {
case MT.BYTE_STRING:
val = parent.slice()
break
case MT.UTF8_STRING:
val = parent.toString('utf-8')
break
}
}
const old = parent
parent = parent[SYMS.PARENT]
delete old[SYMS.PARENT]
delete old[MAJOR]
}
if (!again) {
return val
}
}
}
}
Decoder.NOT_FOUND = NOT_FOUND
module.exports = Decoder

229
node_modules/cbor/lib/diagnose.js generated vendored Normal file
View File

@@ -0,0 +1,229 @@
'use strict'
const stream = require('stream')
const util = require('util')
const Decoder = require('./decoder')
const Simple = require('./simple')
const utils = require('./utils')
const constants = require('./constants')
const bignumber = require('bignumber.js').BigNumber
const NoFilter = require('nofilter')
const MT = constants.MT
const SYMS = constants.SYMS
/**
* Output the diagnostic format from a stream of CBOR bytes.
*
* @extends {stream.Transform}
*/
class Diagnose extends stream.Transform {
/**
* Creates an instance of Diagnose.
*
* @param {Object} [options={}] - options for creation
* @param {string} [options.separator='\n'] - output between detected objects
* @param {boolean} [options.stream_errors=false] - put error info into the
* output stream
* @param {number} [options.max_depth=-1] - -1 for "until you run out of
* memory". Set this to a finite positive number for un-trusted inputs.
* Most standard inputs won't nest more than 100 or so levels; I've tested
* into the millions before running out of memory.
*/
constructor(options) {
const opts = Object.assign({
separator: '\n',
stream_errors: false
}, options, {
readableObjectMode: false,
writableObjectMode: false
})
const separator = opts.separator
delete opts.separator
const stream_errors = opts.stream_errors
delete opts.stream_errors
super(opts)
this.float_bytes = -1
this.separator = separator
this.stream_errors = stream_errors
this.parser = new Decoder(opts)
this.parser.on('more-bytes', this._on_more.bind(this))
this.parser.on('value', this._on_value.bind(this))
this.parser.on('start', this._on_start.bind(this))
this.parser.on('stop', this._on_stop.bind(this))
this.parser.on('data', this._on_data.bind(this))
this.parser.on('error', this._on_error.bind(this))
}
_transform(fresh, encoding, cb) {
return this.parser.write(fresh, encoding, cb)
}
_flush(cb) {
return this.parser._flush((er) => {
if (this.stream_errors) {
if (er) {
this._on_error(er)
}
return cb()
} else {
return cb(er)
}
})
}
/**
* Convenience function to return a string in diagnostic format.
*
* @param {(Buffer|string)} input - the CBOR bytes to format
* @param {string} [encoding='hex'] - the encoding of input, ignored if
* input is Buffer
* @param {function(Error, string): undefined} cb - callback
* @returns {Promise} if callback not specified
*/
static diagnose(input, encoding, cb) {
if (input == null) {
throw new Error('input required')
}
let opts = {}
let encod = 'hex'
switch (typeof encoding) {
case 'function':
cb = encoding
encod = utils.guessEncoding(input)
break
case 'object':
opts = utils.extend({}, encoding)
encod = (opts.encoding != null) ?
opts.encoding : utils.guessEncoding(input)
delete opts.encoding
break
default:
encod = (encoding != null) ? encoding : 'hex'
}
const bs = new NoFilter()
const d = new Diagnose(opts)
let p = null
if (typeof cb === 'function') {
d.on('end', () => cb(null, bs.toString('utf8')))
d.on('error', cb)
} else {
p = new Promise((resolve, reject) => {
d.on('end', () => resolve(bs.toString('utf8')))
return d.on('error', reject)
})
}
d.pipe(bs)
d.end(input, encod)
return p
}
_on_error(er) {
if (this.stream_errors) {
return this.push(er.toString())
} else {
return this.emit('error', er)
}
}
_on_more(mt, len, parent_mt, pos) {
if (mt === MT.SIMPLE_FLOAT) {
return this.float_bytes = {
2: 1,
4: 2,
8: 3
}[len]
}
}
_fore(parent_mt, pos) {
switch (parent_mt) {
case MT.BYTE_STRING:
case MT.UTF8_STRING:
case MT.ARRAY:
if (pos > 0) {
return this.push(', ')
}
break
case MT.MAP:
if (pos > 0) {
if (pos % 2) {
return this.push(': ')
} else {
return this.push(', ')
}
}
}
}
_on_value(val, parent_mt, pos) {
if (val === SYMS.BREAK) {
return
}
this._fore(parent_mt, pos)
return this.push((() => {
switch (false) {
case val !== SYMS.NULL:
return 'null'
case val !== SYMS.UNDEFINED:
return 'undefined'
case typeof val !== 'string':
return JSON.stringify(val)
case !(this.float_bytes > 0):
const fb = this.float_bytes
this.float_bytes = -1
return (util.inspect(val)) + '_' + fb
case !Buffer.isBuffer(val):
return 'h\'' + (val.toString('hex')) + '\''
case !(val instanceof bignumber):
return val.toString()
default:
return util.inspect(val)
}
})())
}
_on_start(mt, tag, parent_mt, pos) {
this._fore(parent_mt, pos)
switch (mt) {
case MT.TAG:
this.push(`${tag}(`)
break
case MT.ARRAY:
this.push('[')
break
case MT.MAP:
this.push('{')
break
case MT.BYTE_STRING:
case MT.UTF8_STRING:
this.push('(')
break
}
if (tag === SYMS.STREAM) {
return this.push('_ ')
}
}
_on_stop(mt) {
switch (mt) {
case MT.TAG:
return this.push(')')
case MT.ARRAY:
return this.push(']')
case MT.MAP:
return this.push('}')
case MT.BYTE_STRING:
case MT.UTF8_STRING:
return this.push(')')
}
}
_on_data() {
return this.push(this.separator)
}
}
module.exports = Diagnose

738
node_modules/cbor/lib/encoder.js generated vendored Normal file
View File

@@ -0,0 +1,738 @@
'use strict'
const stream = require('stream')
const url = require('url')
const bignumber = require('bignumber.js').BigNumber
const NoFilter = require('nofilter')
const Tagged = require('./tagged')
const Simple = require('./simple')
const utils = require('./utils')
const constants = require('./constants')
const MT = constants.MT
const NUMBYTES = constants.NUMBYTES
const SHIFT32 = constants.SHIFT32
const SYMS = constants.SYMS
const TAG = constants.TAG
const HALF = (constants.MT.SIMPLE_FLOAT << 5) | constants.NUMBYTES.TWO
const FLOAT = (constants.MT.SIMPLE_FLOAT << 5) | constants.NUMBYTES.FOUR
const DOUBLE = (constants.MT.SIMPLE_FLOAT << 5) | constants.NUMBYTES.EIGHT
const TRUE = (constants.MT.SIMPLE_FLOAT << 5) | constants.SIMPLE.TRUE
const FALSE = (constants.MT.SIMPLE_FLOAT << 5) | constants.SIMPLE.FALSE
const UNDEFINED = (constants.MT.SIMPLE_FLOAT << 5) | constants.SIMPLE.UNDEFINED
const NULL = (constants.MT.SIMPLE_FLOAT << 5) | constants.SIMPLE.NULL
const BI = utils.bigIntize(constants.BI)
const BN = constants.BN
const BUF_NAN = Buffer.from('f97e00', 'hex')
const BUF_INF_NEG = Buffer.from('f9fc00', 'hex')
const BUF_INF_POS = Buffer.from('f97c00', 'hex')
const BUF_NEG_ZERO = Buffer.from('f98000', 'hex')
const LOOP_DETECT = Symbol('CBOR_LOOP_DETECT')
/**
* Transform JavaScript values into CBOR bytes. The `Writable` side of
* the stream is in object mode.
*
* @extends {stream.Transform}
*/
class Encoder extends stream.Transform {
/**
* Creates an instance of Encoder.
*
* @param {Object} [options={}] - options for the encoder
* @param {any[]} [options.genTypes=[]] - array of pairs of `type`,
* `function(Encoder)` for semantic types to be encoded. Not needed
* for Array, Date, Buffer, Map, RegExp, Set, Url, or bignumber.
* @param {boolean} [options.canonical=false] - should the output be
* canonicalized
* @param {boolean|Symbol} [options.detectLoops=false] - should object loops
* be detected? This will currently modify the encoded object graph
* by adding a Symbol property to each object. If this bothers you,
* call `removeLoopDetectors` on the encoded object when done. Do not
* encode the same object twice on the same encoder, without calling
* `removeLoopDetectors` in between.
* @param {("number"|"float"|"int"|"string")} [options.dateType="number"] -
* how should dates be encoded? "number" means float or int, if no
* fractional seconds.
* @param {any} [options.encodeUndefined=undefined] - How should an
* "undefined" in the input be encoded. By default, just encode a CBOR
* undefined. If this is a buffer, use those bytes without re-encoding
* them. If this is a function, the function will be called (which is
* a good time to throw an exception, if that's what you want), and the
* return value will be used according to these rules. Anything
* else will be encoded as CBOR.
* @param {boolean} [options.disallowUndefinedKeys=false] - Should "undefined"
* be disallowed as a key in a Map that is serialized? If this is true,
* encode(new Map([[undefined, 1]])) will throw an exception. Note that
* it is impossible to get a key of undefined in a normal JS object.
* @param {boolean} [options.collapseBigIntegers=false] - Should integers
* that come in as BigNumber integers and ECMAscript bigint's be encoded
* as normal CBOR integers if they fit, discarding type information?
*/
constructor(options) {
const opts = Object.assign({}, options, {
readableObjectMode: false,
writableObjectMode: true
})
super(opts)
this.canonical = opts.canonical
this.encodeUndefined = opts.encodeUndefined
this.disallowUndefinedKeys = !!opts.disallowUndefinedKeys
this.dateType = (opts.dateType != null) ?
opts.dateType.toLowerCase() : 'number'
this.collapseBigIntegers = !!opts.collapseBigIntegers
// new Symbol for each instance. Note: means we can't re-use the same
// encoder and encoded object
if (typeof(opts.detectLoops) === 'symbol') {
this.detectLoops = opts.detectLoops
} else {
this.detectLoops = !!opts.detectLoops ? Symbol('CBOR_DETECT') : null
}
this.semanticTypes = [
Array, this._pushArray,
Date, this._pushDate,
Buffer, this._pushBuffer,
Map, this._pushMap,
NoFilter, this._pushNoFilter,
RegExp, this._pushRegexp,
Set, this._pushSet,
bignumber, this._pushBigNumber,
ArrayBuffer, this._pushUint8Array,
Uint8ClampedArray, this._pushUint8Array,
Uint8Array, this._pushUint8Array,
Uint16Array, this._pushArray,
Uint32Array, this._pushArray,
Int8Array, this._pushArray,
Int16Array, this._pushArray,
Int32Array, this._pushArray,
Float32Array, this._pushFloat32Array,
Float64Array, this._pushFloat64Array
]
// tsc doesn't know about old Url
if (url['Url']) {
this.semanticTypes.push(url['Url'], this._pushUrl)
}
if (url['URL']) {
this.semanticTypes.push(url['URL'], this._pushURL)
}
const addTypes = opts.genTypes || []
for (let i = 0, len = addTypes.length; i < len; i += 2) {
this.addSemanticType(addTypes[i], addTypes[i + 1])
}
}
_transform(fresh, encoding, cb) {
const ret = this.pushAny(fresh)
// Old transformers might not return bool. undefined !== false
return cb((ret === false) ? new Error('Push Error') : undefined)
}
_flush(cb) {
return cb()
}
/**
* @callback encodeFunction
* @param {Encoder} encoder - the encoder to serialize into. Call "write"
* on the encoder as needed.
* @return {bool} - true on success, else false
*/
/**
* Add an encoding function to the list of supported semantic types. This is
* useful for objects for which you can't add an encodeCBOR method
*
* @param {any} type
* @param {any} fun
* @returns {encodeFunction}
*/
addSemanticType(type, fun) {
for (let i = 0, len = this.semanticTypes.length; i < len; i += 2) {
const typ = this.semanticTypes[i]
if (typ === type) {
const old = this.semanticTypes[i + 1]
this.semanticTypes[i + 1] = fun
return old
}
}
this.semanticTypes.push(type, fun)
return null
}
_pushUInt8(val) {
const b = Buffer.allocUnsafe(1)
b.writeUInt8(val, 0)
return this.push(b)
}
_pushUInt16BE(val) {
const b = Buffer.allocUnsafe(2)
b.writeUInt16BE(val, 0)
return this.push(b)
}
_pushUInt32BE(val) {
const b = Buffer.allocUnsafe(4)
b.writeUInt32BE(val, 0)
return this.push(b)
}
_pushFloatBE(val) {
const b = Buffer.allocUnsafe(4)
b.writeFloatBE(val, 0)
return this.push(b)
}
_pushDoubleBE(val) {
const b = Buffer.allocUnsafe(8)
b.writeDoubleBE(val, 0)
return this.push(b)
}
_pushNaN() {
return this.push(BUF_NAN)
}
_pushInfinity(obj) {
const half = (obj < 0) ? BUF_INF_NEG : BUF_INF_POS
return this.push(half)
}
_pushFloat(obj) {
if (this.canonical) {
// TODO: is this enough slower to hide behind canonical?
// It's certainly enough of a hack (see utils.parseHalf)
// From section 3.9:
// If a protocol allows for IEEE floats, then additional canonicalization
// rules might need to be added. One example rule might be to have all
// floats start as a 64-bit float, then do a test conversion to a 32-bit
// float; if the result is the same numeric value, use the shorter value
// and repeat the process with a test conversion to a 16-bit float. (This
// rule selects 16-bit float for positive and negative Infinity as well.)
// which seems pretty much backwards to me.
const b2 = Buffer.allocUnsafe(2)
if (utils.writeHalf(b2, obj)) {
if (utils.parseHalf(b2) === obj) {
return this._pushUInt8(HALF) && this.push(b2)
}
}
}
if (Math.fround(obj) === obj) {
return this._pushUInt8(FLOAT) && this._pushFloatBE(obj)
}
return this._pushUInt8(DOUBLE) && this._pushDoubleBE(obj)
}
_pushInt(obj, mt, orig) {
const m = mt << 5
switch (false) {
case !(obj < 24):
return this._pushUInt8(m | obj)
case !(obj <= 0xff):
return this._pushUInt8(m | NUMBYTES.ONE) && this._pushUInt8(obj)
case !(obj <= 0xffff):
return this._pushUInt8(m | NUMBYTES.TWO) && this._pushUInt16BE(obj)
case !(obj <= 0xffffffff):
return this._pushUInt8(m | NUMBYTES.FOUR) && this._pushUInt32BE(obj)
case !(obj <= Number.MAX_SAFE_INTEGER):
return this._pushUInt8(m | NUMBYTES.EIGHT) &&
this._pushUInt32BE(Math.floor(obj / SHIFT32)) &&
this._pushUInt32BE(obj % SHIFT32)
default:
if (mt === MT.NEG_INT) {
return this._pushFloat(orig)
} else {
return this._pushFloat(obj)
}
}
}
_pushIntNum(obj) {
if (Object.is(obj, -0)) {
return this.push(BUF_NEG_ZERO)
}
if (obj < 0) {
return this._pushInt(-obj - 1, MT.NEG_INT, obj)
} else {
return this._pushInt(obj, MT.POS_INT)
}
}
_pushNumber(obj) {
switch (false) {
case !isNaN(obj):
return this._pushNaN()
case isFinite(obj):
return this._pushInfinity(obj)
case Math.round(obj) !== obj:
return this._pushIntNum(obj)
default:
return this._pushFloat(obj)
}
}
_pushString(obj) {
const len = Buffer.byteLength(obj, 'utf8')
return this._pushInt(len, MT.UTF8_STRING) && this.push(obj, 'utf8')
}
_pushBoolean(obj) {
return this._pushUInt8(obj ? TRUE : FALSE)
}
_pushUndefined(obj) {
switch (typeof this.encodeUndefined) {
case 'undefined':
return this._pushUInt8(UNDEFINED)
case 'function':
return this.pushAny(this.encodeUndefined.call(this, obj))
case 'object':
if (Buffer.isBuffer(this.encodeUndefined)) {
return this.push(this.encodeUndefined)
}
}
return this.pushAny(this.encodeUndefined)
}
_pushNull(obj) {
return this._pushUInt8(NULL)
}
_pushArray(gen, obj) {
const len = obj.length
if (!gen._pushInt(len, MT.ARRAY)) {
return false
}
for (let j = 0; j < len; j++) {
if (!gen.pushAny(obj[j])) {
return false
}
}
return true
}
_pushTag(tag) {
return this._pushInt(tag, MT.TAG)
}
_pushDate(gen, obj) {
switch (gen.dateType) {
case 'string':
return gen._pushTag(TAG.DATE_STRING) &&
gen._pushString(obj.toISOString())
case 'int':
case 'integer':
return gen._pushTag(TAG.DATE_EPOCH) &&
gen._pushIntNum(Math.round(obj / 1000))
case 'float':
// force float
return gen._pushTag(TAG.DATE_EPOCH) &&
gen._pushFloat(obj / 1000)
case 'number':
default:
// if we happen to have an integral number of seconds,
// use integer. Otherwise, use float.
return gen._pushTag(TAG.DATE_EPOCH) &&
gen.pushAny(obj / 1000)
}
}
_pushBuffer(gen, obj) {
return gen._pushInt(obj.length, MT.BYTE_STRING) && gen.push(obj)
}
_pushNoFilter(gen, obj) {
return gen._pushBuffer(gen, obj.slice())
}
_pushRegexp(gen, obj) {
return gen._pushTag(TAG.REGEXP) && gen.pushAny(obj.source)
}
_pushSet(gen, obj) {
if (!gen._pushInt(obj.size, MT.ARRAY)) {
return false
}
for (const x of obj) {
if (!gen.pushAny(x)) {
return false
}
}
return true
}
_pushUrl(gen, obj) {
return gen._pushTag(TAG.URI) && gen.pushAny(obj.format())
}
_pushURL(gen, obj) {
return gen._pushTag(TAG.URI) && gen.pushAny(obj.toString())
}
/**
* @param {bignumber} obj
* @private
*/
_pushBigint(obj) {
let m = MT.POS_INT
let tag = TAG.POS_BIGINT
if (obj.isNegative()) {
obj = obj.negated().minus(1)
m = MT.NEG_INT
tag = TAG.NEG_BIGINT
}
if (this.collapseBigIntegers &&
obj.lte(BN.MAXINT64)) {
// special handiling for 64bits
if (obj.lte(BN.MAXINT32)) {
return this._pushInt(obj.toNumber(), m)
}
return this._pushUInt8((m << 5) | NUMBYTES.EIGHT) &&
this._pushUInt32BE(obj.dividedToIntegerBy(BN.SHIFT32).toNumber()) &&
this._pushUInt32BE(obj.mod(BN.SHIFT32).toNumber())
}
let str = obj.toString(16)
if (str.length % 2) {
str = '0' + str
}
const buf = Buffer.from(str, 'hex')
return this._pushTag(tag) && this._pushBuffer(this, buf)
}
/**
* @param {bigint} obj
* @private
*/
_pushJSBigint(obj) {
let m = MT.POS_INT
let tag = TAG.POS_BIGINT
// BigInt doesn't have -0
if (obj < 0) {
obj = -obj + BI.MINUS_ONE
m = MT.NEG_INT
tag = TAG.NEG_BIGINT
}
if (this.collapseBigIntegers &&
(obj <= BI.MAXINT64)) {
// special handiling for 64bits
if (obj <= 0xffffffff) {
return this._pushInt(Number(obj), m)
}
return this._pushUInt8((m << 5) | NUMBYTES.EIGHT) &&
this._pushUInt32BE(Number(obj / BI.SHIFT32)) &&
this._pushUInt32BE(Number(obj % BI.SHIFT32))
}
let str = obj.toString(16)
if (str.length % 2) {
str = '0' + str
}
const buf = Buffer.from(str, 'hex')
return this._pushTag(tag) && this._pushBuffer(this, buf)
}
_pushBigNumber(gen, obj) {
if (obj.isNaN()) {
return gen._pushNaN()
}
if (!obj.isFinite()) {
return gen._pushInfinity(obj.isNegative() ? -Infinity : Infinity)
}
if (obj.isInteger()) {
return gen._pushBigint(obj)
}
if (!(gen._pushTag(TAG.DECIMAL_FRAC) &&
gen._pushInt(2, MT.ARRAY))) {
return false
}
const dec = obj.decimalPlaces()
const slide = obj.times(new bignumber(10).pow(dec))
if (!gen._pushIntNum(-dec)) {
return false
}
if (slide.abs().isLessThan(BN.MAXINT)) {
return gen._pushIntNum(slide.toNumber())
} else {
return gen._pushBigint(slide)
}
}
_pushMap(gen, obj) {
if (!gen._pushInt(obj.size, MT.MAP)) {
return false
}
// memoizing the cbor only helps in certain cases, and hurts in most
// others. Just avoid it.
if (gen.canonical) {
// keep the key/value pairs together, so we don't have to do odd
// gets with object keys later
const entries = [...obj.entries()]
const enc = new Encoder(this) // TODO: fix genTypes
const bs = new NoFilter({highWaterMark:this.readableHighWaterMark})
enc.pipe(bs)
entries.sort(([a], [b]) => {
// a, b are the keys
enc.pushAny(a)
const a_cbor = bs.read()
enc.pushAny(b)
const b_cbor = bs.read()
return a_cbor.compare(b_cbor)
})
for (const [k, v] of entries) {
if (gen.disallowUndefinedKeys && (typeof k === 'undefined')) {
throw new Error('Invalid Map key: undefined')
}
if (!(gen.pushAny(k) && gen.pushAny(v))) {
return false
}
}
} else {
for (const [k, v] of obj) {
if (gen.disallowUndefinedKeys && (typeof k === 'undefined')) {
throw new Error('Invalid Map key: undefined')
}
if (!(gen.pushAny(k) && gen.pushAny(v))) {
return false
}
}
}
return true
}
_pushUint8Array(gen, obj) {
return gen._pushBuffer(gen, Buffer.from(obj))
}
_pushFloat32Array(gen, obj) {
const len = obj.length
if (!gen._pushInt(len, MT.ARRAY)) {
return false
}
for (let j = 0; j < len; j++) {
if (!gen._pushUInt8(FLOAT) || !gen._pushFloatBE(obj[j])) {
return false
}
}
return true
}
_pushFloat64Array(gen, obj) {
const len = obj.length
if (!gen._pushInt(len, MT.ARRAY)) {
return false
}
for (let j = 0; j < len; j++) {
if (!gen._pushUInt8(DOUBLE) || !gen._pushDoubleBE(obj[j])) {
return false
}
}
return true
}
removeLoopDetectors(obj) {
if (!this.detectLoops || (typeof(obj) !== 'object') || !obj) {
return false
}
const dl = obj[LOOP_DETECT]
if (!dl || (dl !== this.detectLoops)) {
// ironically, use loop marking to detect loops on removal as well
return false
}
delete obj[LOOP_DETECT]
if (Array.isArray(obj)) {
for (const i of obj) {
this.removeLoopDetectors(i)
}
} else {
for (const k in obj) {
this.removeLoopDetectors(obj[k])
}
}
return true
}
_pushObject(obj) {
if (!obj) {
return this._pushNull(obj)
}
if (this.detectLoops) {
if (obj[LOOP_DETECT] === this.detectLoops) {
throw new Error('Loop detected while CBOR encoding')
} else {
obj[LOOP_DETECT] = this.detectLoops
}
}
const f = obj.encodeCBOR
if (typeof f === 'function') {
return f.call(obj, this)
}
for (let i = 0, len1 = this.semanticTypes.length; i < len1; i += 2) {
const typ = this.semanticTypes[i]
if (obj instanceof typ) {
return this.semanticTypes[i + 1].call(obj, this, obj)
}
}
const keys = Object.keys(obj)
const cbor_keys = {}
if (this.canonical) {
// note: this can't be a normal sort, because 'b' needs to sort before
// 'aa'
keys.sort((a, b) => {
// Always strings, so don't bother to pass options.
// hold on to the cbor versions, since there's no need
// to encode more than once
const a_cbor = cbor_keys[a] || (cbor_keys[a] = Encoder.encode(a))
const b_cbor = cbor_keys[b] || (cbor_keys[b] = Encoder.encode(b))
return a_cbor.compare(b_cbor)
})
}
if (!this._pushInt(keys.length, MT.MAP)) {
return false
}
let ck
for (let j = 0, len2 = keys.length; j < len2; j++) {
const k = keys[j]
if (this.canonical && ((ck = cbor_keys[k]))) {
if (!this.push(ck)) { // already a Buffer
return false
}
} else {
if (!this._pushString(k)) {
return false
}
}
if (!this.pushAny(obj[k])) {
return false
}
}
return true
}
/**
* Push any supported type onto the encoded stream
*
* @param {any} obj
* @returns {boolean} true on success
*/
pushAny(obj) {
switch (typeof obj) {
case 'number':
return this._pushNumber(obj)
case 'bigint':
return this._pushJSBigint(obj)
case 'string':
return this._pushString(obj)
case 'boolean':
return this._pushBoolean(obj)
case 'undefined':
return this._pushUndefined(obj)
case 'object':
return this._pushObject(obj)
case 'symbol':
switch (obj) {
case SYMS.NULL:
return this._pushNull(null)
case SYMS.UNDEFINED:
return this._pushUndefined(void 0)
// TODO: Add pluggable support for other symbols
default:
throw new Error('Unknown symbol: ' + obj.toString())
}
default:
throw new Error(
'Unknown type: ' + typeof obj + ', ' +
(!!obj ? obj.toString() : ''))
}
}
/* backwards-compat wrapper */
_pushAny(obj) {
// TODO: write deprecation warning
return this.pushAny(obj)
}
_encodeAll(objs) {
const bs = new NoFilter({ highWaterMark:this.readableHighWaterMark })
this.pipe(bs)
for (const o of objs) {
this.pushAny(o)
}
this.end()
return bs.read()
}
/**
* Encode one or more JavaScript objects, and return a Buffer containing the
* CBOR bytes.
*
* @param {...any} objs - the objects to encode
* @returns {Buffer} - the encoded objects
*/
static encode(...objs) {
return new Encoder()._encodeAll(objs)
}
/**
* Encode one or more JavaScript objects canonically (slower!), and return
* a Buffer containing the CBOR bytes.
*
* @param {...any} objs - the objects to encode
* @returns {Buffer} - the encoded objects
*/
static encodeCanonical(...objs) {
return new Encoder({canonical: true})._encodeAll(objs)
}
/**
* Encode one JavaScript object using the given options.
*
* @static
* @param {any} obj - the object to encode
* @param {Object?} options - passed to the Encoder constructor
* @returns {Buffer} - the encoded objects
*/
static encodeOne(obj, options) {
return new Encoder(options)._encodeAll([obj])
}
/**
* Encode one JavaScript object using the given options in a way that
* is more resilient to objects being larger than the highWaterMark
* number of bytes. As with the other static encode functions, this
* will still use a large amount of memory. Use a stream-based approach
* directly if you need to process large and complicated inputs.
*
* @param {any} obj - the object to encode
* @param {Object?} options - passed to the Encoder constructor
*/
static encodeAsync(obj, options) {
return new Promise((resolve, reject) => {
const bufs = []
const enc = new Encoder(options)
enc.on('data', buf => bufs.push(buf))
enc.on('error', reject)
enc.on('finish', () => resolve(Buffer.concat(bufs)))
enc.pushAny(obj)
enc.end()
})
}
}
module.exports = Encoder

176
node_modules/cbor/lib/map.js generated vendored Normal file
View File

@@ -0,0 +1,176 @@
'use strict'
const encoder = require('./encoder')
const decoder = require('./decoder')
const constants = require('./constants')
const MT = constants.MT
/**
* Wrapper around a JavaScript Map object that allows the keys to be
* any complex type. The base Map object allows this, but will only
* compare the keys by identity, not by value. CborMap translates keys
* to CBOR first (and base64's them to ensure by-value comparison).
*
* This is not a subclass of Object, because it would be tough to get
* the semantics to be an exact match.
*
* @class CborMap
* @extends {Map}
*/
class CborMap extends Map {
/**
* Creates an instance of CborMap.
* @param {Iterable<any, any>} [iterable] An Array or other iterable
* object whose elements are key-value pairs (arrays with two elements, e.g.
* <code>[[ 1, 'one' ],[ 2, 'two' ]]</code>). Each key-value pair is added
* to the new CborMap; null values are treated as undefined.
*/
constructor(iterable) {
super(iterable)
}
/**
* @private
*/
static _encode(key) {
return encoder.encodeCanonical(key).toString('base64')
}
/**
* @private
*/
static _decode(key) {
return decoder.decodeFirstSync(key, 'base64')
}
/**
* Retrieve a specified element.
*
* @param {any} key The key identifying the element to retrieve.
* Can be any type, which will be serialized into CBOR and compared by
* value.
* @returns {any} The element if it exists, or <code>undefined</code>.
*/
get(key) {
return super.get(CborMap._encode(key))
}
/**
* Adds or updates an element with a specified key and value.
*
* @param {any} key The key identifying the element to store.
* Can be any type, which will be serialized into CBOR and compared by
* value.
* @param {any} val The element to store
*/
set(key, val) {
return super.set(CborMap._encode(key), val)
}
/**
* Removes the specified element.
*
* @param {any} key The key identifying the element to delete.
* Can be any type, which will be serialized into CBOR and compared by
* value.
* @returns {boolean}
*/
delete(key) {
return super.delete(CborMap._encode(key))
}
/**
* Does an element with the specified key exist?
*
* @param {any} key The key identifying the element to check.
* Can be any type, which will be serialized into CBOR and compared by
* value.
* @returns {boolean}
*/
has(key) {
return super.has(CborMap._encode(key))
}
/**
* Returns a new Iterator object that contains the keys for each element
* in the Map object in insertion order. The keys are decoded into their
* original format.
*
* @returns {IterableIterator<any>}
*/
*keys() {
for (const k of super.keys()) {
yield CborMap._decode(k)
}
}
/**
* Returns a new Iterator object that contains the [key, value] pairs for
* each element in the Map object in insertion order.
*
* @returns {IterableIterator}
*/
*entries() {
for (const kv of super.entries()) {
yield [CborMap._decode(kv[0]), kv[1]]
}
}
/**
* Returns a new Iterator object that contains the [key, value] pairs for
* each element in the Map object in insertion order.
*
* @returns {IterableIterator}
*/
[Symbol.iterator]() {
return this.entries()
}
/**
* Executes a provided function once per each key/value pair in the Map
* object, in insertion order.
*
* @param {function(any, any, Map): undefined} fun Function to execute for
* each element, which takes a value, a key, and the Map being traversed.
* @param {any} thisArg Value to use as this when executing callback
*/
forEach(fun, thisArg) {
if (typeof(fun) !== 'function') {
throw new TypeError('Must be function')
}
for (const kv of super.entries()) {
fun.call(this, kv[1], CborMap._decode(kv[0]), this)
}
}
/**
* Push the simple value onto the CBOR stream
*
* @param {Object} gen The generator to push onto
* @returns {boolean} true on success
*/
encodeCBOR(gen) {
if (!gen._pushInt(this.size, MT.MAP)) {
return false
}
if (gen.canonical) {
const entries = Array.from(super.entries())
.map((kv) => [Buffer.from(kv[0], 'base64'), kv[1]])
entries.sort((a, b) => a[0].compare(b[0]))
for (const kv of entries) {
if (!(gen.push(kv[0]) && gen.pushAny(kv[1]))) {
return false
}
}
} else {
for (const kv of super.entries()) {
if (!(gen.push(Buffer.from(kv[0], 'base64')) && gen.pushAny(kv[1]))) {
return false
}
}
}
return true
}
}
module.exports = CborMap

115
node_modules/cbor/lib/simple.js generated vendored Normal file
View File

@@ -0,0 +1,115 @@
'use strict'
const util = require('util')
const constants = require('./constants')
const MT = constants.MT
const SIMPLE = constants.SIMPLE
const SYMS = constants.SYMS
/**
* A CBOR Simple Value that does not map onto a known constant.
*/
class Simple {
/**
* Creates an instance of Simple.
*
* @param {number} value - the simple value's integer value
*/
constructor(value) {
if (typeof value !== 'number') {
throw new Error('Invalid Simple type: ' + (typeof value))
}
if ((value < 0) || (value > 255) || ((value|0) !== value)) {
throw new Error('value must be a small positive integer: ' + value)
}
this.value = value
}
/**
* Debug string for simple value
*
* @returns {string} simple(value)
*/
toString() {
return 'simple(' + this.value + ')'
}
/**
* Debug string for simple value
*
* @returns {string} simple(value)
*/
[util.inspect.custom](depth, opts) {
return 'simple(' + this.value + ')'
}
/**
* Debug string for simple value (backward-compatibility version)
*
* @returns {string} simple(value)
*/
inspect(depth, opts) {
return 'simple(' + this.value + ')'
}
/**
* Push the simple value onto the CBOR stream
*
* @param {Object} gen The generator to push onto
*/
encodeCBOR(gen) {
return gen._pushInt(this.value, MT.SIMPLE_FLOAT)
}
/**
* Is the given object a Simple?
*
* @param {any} obj - object to test
* @returns {boolean} - is it Simple?
*/
static isSimple(obj) {
return obj instanceof Simple
}
/**
* Decode from the CBOR additional information into a JavaScript value.
* If the CBOR item has no parent, return a "safe" symbol instead of
* `null` or `undefined`, so that the value can be passed through a
* stream in object mode.
*
* @param {number} val - the CBOR additional info to convert
* @param {boolean} [has_parent=true] - Does the CBOR item have a parent?
* @param {boolean} [parent_indefinite=false] - Is the parent element
* indefinitely encoded?
* @returns {(null|undefined|boolean|Symbol|Simple)} - the decoded value
*/
static decode(val, has_parent=true, parent_indefinite=false) {
switch (val) {
case SIMPLE.FALSE:
return false
case SIMPLE.TRUE:
return true
case SIMPLE.NULL:
if (has_parent) {
return null
} else {
return SYMS.NULL
}
case SIMPLE.UNDEFINED:
if (has_parent) {
return void 0
} else {
return SYMS.UNDEFINED
}
case -1:
if (!has_parent || !parent_indefinite) {
throw new Error('Invalid BREAK')
}
return SYMS.BREAK
default:
return new Simple(val)
}
}
}
module.exports = Simple

116
node_modules/cbor/lib/tagged.js generated vendored Normal file
View File

@@ -0,0 +1,116 @@
'use strict'
const bignumber = require('bignumber.js').BigNumber
const utils = require('./utils')
const url = require('url')
const MINUS_ONE = new bignumber(-1)
const TEN = new bignumber(10)
const TWO = new bignumber(2)
/**
* A CBOR tagged item, where the tag does not have semantics specified at the
* moment, or those semantics threw an error during parsing. Typically this will
* be an extension point you're not yet expecting.
*/
class Tagged {
/**
* Creates an instance of Tagged.
*
* @param {number} tag - the number of the tag
* @param {any} value - the value inside the tag
* @param {Error} [err] - the error that was thrown parsing the tag, or null
*/
constructor(tag, value, err) {
this.tag = tag
this.value = value
this.err = err
if (typeof this.tag !== 'number') {
throw new Error('Invalid tag type (' + (typeof this.tag) + ')')
}
if ((this.tag < 0) || ((this.tag | 0) !== this.tag)) {
throw new Error('Tag must be a positive integer: ' + this.tag)
}
}
/**
* Convert to a String
*
* @returns {string} string of the form '1(2)'
*/
toString() {
return `${this.tag}(${JSON.stringify(this.value)})`
}
/**
* Push the simple value onto the CBOR stream
*
* @param {Object} gen The generator to push onto
*/
encodeCBOR(gen) {
gen._pushTag(this.tag)
return gen.pushAny(this.value)
}
/**
* If we have a converter for this type, do the conversion. Some converters
* are built-in. Additional ones can be passed in. If you want to remove
* a built-in converter, pass a converter in whose value is 'null' instead
* of a function.
*
* @param {Object} converters - keys in the object are a tag number, the value
* is a function that takes the decoded CBOR and returns a JavaScript value
* of the appropriate type. Throw an exception in the function on errors.
* @returns {any} - the converted item
*/
convert(converters) {
let f = converters != null ? converters[this.tag] : void 0
if (typeof f !== 'function') {
f = Tagged['_tag_' + this.tag]
if (typeof f !== 'function') {
return this
}
}
try {
return f.call(Tagged, this.value)
} catch (error) {
this.err = error
return this
}
}
static _tag_0(v) {
return new Date(v)
}
static _tag_1(v) {
return new Date(v * 1000)
}
static _tag_2(v) {
return utils.bufferToBignumber(v)
}
static _tag_3(v) {
return MINUS_ONE.minus(utils.bufferToBignumber(v))
}
static _tag_4(v) {
return TEN.pow(v[0]).times(v[1])
}
static _tag_5(v) {
return TWO.pow(v[0]).times(v[1])
}
static _tag_32(v) {
return url.parse(v)
}
static _tag_35(v) {
return new RegExp(v)
}
}
module.exports = Tagged

241
node_modules/cbor/lib/utils.js generated vendored Normal file
View File

@@ -0,0 +1,241 @@
'use strict'
const util = require('util')
const bignumber = require('bignumber.js').BigNumber
const constants = require('./constants')
const NUMBYTES = constants.NUMBYTES
const SHIFT32 = constants.SHIFT32
const MAX_SAFE_HIGH = 0x1fffff
exports.hasBigInt = (typeof BigInt === 'function')
/**
* Convert a UTF8-encoded Buffer to a JS string. If possible, throw an error
* on invalid UTF8. Byte Order Marks are not looked at or stripped.
*/
const TD = (typeof TextDecoder === 'function') ? TextDecoder : util.TextDecoder
/* istanbul ignore else */
if (TD) {
// node 11+, browsers : node 8.3+
const td = new TD('utf8', {fatal: true, ignoreBOM: true})
exports.utf8 = (buf) => td.decode(buf)
exports.utf8.checksUTF8 = true
} else {
// TODO: polyfill a slow one or wait for node6 to die
exports.utf8 = (buf) => buf.toString('utf8')
exports.utf8.checksUTF8 = false
}
exports.parseCBORint = function(ai, buf) {
switch (ai) {
case NUMBYTES.ONE:
return buf.readUInt8(0)
case NUMBYTES.TWO:
return buf.readUInt16BE(0)
case NUMBYTES.FOUR:
return buf.readUInt32BE(0)
case NUMBYTES.EIGHT:
const f = buf.readUInt32BE(0)
const g = buf.readUInt32BE(4)
if (f > MAX_SAFE_HIGH) {
return new bignumber(f).times(SHIFT32).plus(g)
} else {
return (f * SHIFT32) + g
}
default:
throw new Error('Invalid additional info for int: ' + ai)
}
}
exports.writeHalf = function writeHalf(buf, half) {
// assume 0, -0, NaN, Infinity, and -Infinity have already been caught
// HACK: everyone settle in. This isn't going to be pretty.
// Translate cn-cbor's C code (from Carsten Borman):
// uint32_t be32;
// uint16_t be16, u16;
// union {
// float f;
// uint32_t u;
// } u32;
// u32.f = float_val;
const u32 = Buffer.allocUnsafe(4)
u32.writeFloatBE(half, 0)
const u = u32.readUInt32BE(0)
// if ((u32.u & 0x1FFF) == 0) { /* worth trying half */
// hildjj: If the lower 13 bits are 0,
// we won't lose anything in the conversion
if ((u & 0x1FFF) !== 0) {
return false
}
// int s16 = (u32.u >> 16) & 0x8000;
// int exp = (u32.u >> 23) & 0xff;
// int mant = u32.u & 0x7fffff;
let s16 = (u >> 16) & 0x8000 // top bit is sign
const exp = (u >> 23) & 0xff // then 5 bits of exponent
const mant = u & 0x7fffff
// if (exp == 0 && mant == 0)
// ; /* 0.0, -0.0 */
// hildjj: zeros already handled. Assert if you don't believe me.
// else if (exp >= 113 && exp <= 142) /* normalized */
// s16 += ((exp - 112) << 10) + (mant >> 13);
if ((exp >= 113) && (exp <= 142)) {
s16 += ((exp - 112) << 10) + (mant >> 13)
} else if ((exp >= 103) && (exp < 113)) {
// else if (exp >= 103 && exp < 113) { /* denorm, exp16 = 0 */
// if (mant & ((1 << (126 - exp)) - 1))
// goto float32; /* loss of precision */
// s16 += ((mant + 0x800000) >> (126 - exp));
if (mant & ((1 << (126 - exp)) - 1)) {
return false
}
s16 += ((mant + 0x800000) >> (126 - exp))
} else {
// } else if (exp == 255 && mant == 0) { /* Inf */
// s16 += 0x7c00;
// hildjj: Infinity already handled
// } else
// goto float32; /* loss of range */
return false
}
// ensure_writable(3);
// u16 = s16;
// be16 = hton16p((const uint8_t*)&u16);
buf.writeUInt16BE(s16)
return true
}
exports.parseHalf = function parseHalf(buf) {
const sign = buf[0] & 0x80 ? -1 : 1
const exp = (buf[0] & 0x7C) >> 2
const mant = ((buf[0] & 0x03) << 8) | buf[1]
if (!exp) {
return sign * 5.9604644775390625e-8 * mant
} else if (exp === 0x1f) {
return sign * (mant ? 0 / 0 : 2e308)
} else {
return sign * Math.pow(2, exp - 25) * (1024 + mant)
}
}
exports.parseCBORfloat = function parseCBORfloat(buf) {
switch (buf.length) {
case 2:
return exports.parseHalf(buf)
case 4:
return buf.readFloatBE(0)
case 8:
return buf.readDoubleBE(0)
default:
throw new Error('Invalid float size: ' + buf.length)
}
}
exports.hex = function hex(s) {
return Buffer.from(s.replace(/^0x/, ''), 'hex')
}
exports.bin = function bin(s) {
s = s.replace(/\s/g, '')
let start = 0
let end = (s.length % 8) || 8
const chunks = []
while (end <= s.length) {
chunks.push(parseInt(s.slice(start, end), 2))
start = end
end += 8
}
return Buffer.from(chunks)
}
exports.extend = function extend(old={}, ...adds) {
const len = adds.length
for (let j = 0; j < len; j++) {
const a = adds[j]
for (const k in a) {
const v = a[k]
old[k] = v
}
}
return old
}
exports.arrayEqual = function arrayEqual(a, b) {
if ((a == null) && (b == null)) {
return true
}
if ((a == null) || (b == null)) {
return false
}
return (a.length === b.length) && a.every((elem, i) => elem === b[i])
}
exports.bufferEqual = function bufferEqual(a, b) {
if ((a == null) && (b == null)) {
return true
}
if ((a == null) || (b == null)) {
return false
}
if (!(Buffer.isBuffer(a) && Buffer.isBuffer(b) && (a.length === b.length))) {
return false
}
const len = a.length
let ret = true
let i
let j
for (i = j = 0; j < len; i = ++j) {
const byte = a[i]
ret = ret && (b[i] === byte)
}
return !!ret
}
exports.bufferToBignumber = function bufferToBignumber(buf) {
return new bignumber(buf.toString('hex'), 16)
}
exports.toBigInt = function toBigInt(num) {
if (!exports.hasBigInt) {
return Number(num) // lossy. Better than nothing?
}
return BigInt(num)
}
exports.bigIntize = function bigIntize(obj) {
const ret = {}
for (const k in obj) { // stupid node 6
ret[k] = exports.toBigInt(obj[k])
}
return ret
}
exports.bufferToBigInt = function bufferToBigInt(buf) {
return exports.toBigInt('0x' + buf.toString('hex'))
}
exports.guessEncoding = function guessEncoding(input) {
if (typeof input == 'string') {
return 'hex'
} else if (Buffer.isBuffer(input)) {
return undefined
}
throw new Error('Unknown input type')
}

120
node_modules/cbor/package.json generated vendored Normal file
View File

@@ -0,0 +1,120 @@
{
"_args": [
[
"cbor@5.1.0",
"C:\\Users\\anelissen.DOMAINE\\Development\\tools\\node\\cbor"
]
],
"_from": "cbor@5.1.0",
"_id": "cbor@5.1.0",
"_inBundle": false,
"_integrity": "sha512-qzEc7kUShdMbWTaUH7X+aHW8owvBU3FS0dfYR1lGYpoZr0mGJhhojLlZJH653x/DfeMZ56h315FRNBUIG1R7qg==",
"_location": "/cbor",
"_phantomChildren": {},
"_requested": {
"type": "version",
"registry": true,
"raw": "cbor@5.1.0",
"name": "cbor",
"escapedName": "cbor",
"rawSpec": "5.1.0",
"saveSpec": null,
"fetchSpec": "5.1.0"
},
"_requiredBy": [
"/",
"/cbor-body-parser"
],
"_resolved": "https://registry.npmjs.org/cbor/-/cbor-5.1.0.tgz",
"_spec": "5.1.0",
"_where": "C:\\Users\\anelissen.DOMAINE\\Development\\tools\\node\\cbor",
"author": {
"name": "Joe Hildebrand",
"email": "joe-github@cursive.net"
},
"ava": {
"files": [
"test/*.ava.js"
]
},
"browser": {
"fs": false
},
"bugs": {
"url": "https://github.com/hildjj/node-cbor/issues"
},
"contributors": [
{
"name": "Patrick Gansterer",
"email": "paroga@paroga.com",
"url": "http://paroga.com/"
},
{
"name": "Artyom Yagilev",
"email": "github@scorpi.org",
"url": "http://scorpi.org/"
},
{
"name": "Denis Lapaev",
"email": "den@lapaev.me",
"url": "http://lapaev.me/"
},
{
"name": "Ruben Bridgewater",
"email": "ruben@bridgewater.de"
},
{
"name": "Burt Harris",
"email": "Burt_Harris_cbor@azxs.33mail.com"
}
],
"dependencies": {
"bignumber.js": "^9.0.0",
"nofilter": "^1.0.4"
},
"description": "Encode and parse data in the Concise Binary Object Representation (CBOR) data format (RFC7049).",
"devDependencies": {
"@types/node": "*",
"ava": "1.4.1",
"concordance": "^5.0",
"garbage": "0.0",
"jsdoc": "^3.6.5",
"light-server": "*",
"minami": "*",
"nyc": "^14.1.1"
},
"directories": {
"lib": "lib"
},
"engines": {
"node": ">=6.0.0"
},
"homepage": "http://hildjj.github.io/node-cbor/",
"keywords": [
"coap",
"cbor",
"json"
],
"license": "MIT",
"main": "./lib/cbor.js",
"name": "cbor",
"repository": {
"type": "git",
"url": "git+ssh://git@github.com/hildjj/node-cbor.git"
},
"scripts": {
"clean": "rm -rf coverage .nyc_output/ docs/api man/*",
"coverage": "nyc npm test",
"coveragehtml": "nyc -r html ava",
"coveralls": "nyc report --reporter=text-lcov | coveralls",
"dev": "light-server -q -s. -w 'lib/*.js # npm run doc' -w 'lib/*.js,test/*.js # npm run coveragehtml' -o /coverage/index.html",
"doc": "jsdoc -c .jsdoc.conf",
"lint": "eslint lib/*.js cli/lib/* cli/bin/* test/*.js",
"man": "mkdir -p man; for f in man_src/*.md; do b=`basename $f`; marked-man $f -o man/${b%.md}.1; gzip -9f man/${b%.md}.1; done",
"predev": "npm run coveragehtml",
"release": "npm version patch && git push --follow-tags && npm publish",
"test": "ava",
"typecheck": "tsc --allowJs --checkJs --noEmit --target ES6 --moduleResolution node lib/*.js"
},
"version": "5.1.0"
}

49
node_modules/cbor/vendor/binary-parse-stream/README.md generated vendored Normal file
View File

@@ -0,0 +1,49 @@
# binary-parse-stream
Painless streaming binary protocol parsers using generators.
## Installation
npm install binary-parse-stream
## Synchronous
This module uses the exact same generator interface as [binary-parser](https://github.com/nathan7/binary-parser), which presents a synchronous interface to a generator parser.
## Usage
```javascript
var BinaryParseStream = require('binary-parse-stream')
, One = BinaryParseStream.One // -1
```
BinaryParseStream is a TransformStream that consumes buffers and outputs objects on the other end.
It expects your subclass to implement a `_parse` method that is a generator.
When your generator yields a number, it'll be fed a buffer of that length from the input.
If it yields -1, it'll be given the value of the first byte instead of a single-byte buffer.
When your generator returns, the return value will be pushed to the output side.
## Example
The following module parses a protocol that consists of a 32-bit unsigned big-endian type parameter, an unsigned 8-bit length parameter, and a buffer of the specified length.
It outputs `{type, buf}` objects.
```js
var BinaryParseStream = require('binary-parse-stream')
, inherits = require('util').inherits
module.exports = SillyProtocolParseStream
inherits(SillyProtocolParseStream, BinaryParseStream)
function SillyProtocolParseStream(options) {
BinaryParseStream.call(this, options)
}
SillyProtocolParseStream.prototype._parse = function*() {
var type = (yield 4).readUInt32BE(0, true)
, length = yield -1
, buf = yield length
return { type: type, buf: buf }
}
```
There is also a shorter syntax for when you don't want to explicitly subclass: `BinaryParseStream.extend(function*())`.

84
node_modules/cbor/vendor/binary-parse-stream/index.js generated vendored Normal file
View File

@@ -0,0 +1,84 @@
// Tweaked version of nathan7's binary-parse-stream
// (see https://github.com/nathan7/binary-parse-stream)
// Uses NoFilter instead of the readable in the original. Removes
// the ability to read -1, which was odd and un-needed.
// License for binary-parse-stream: MIT
// binary-parse-stream is now unmaintained, so I'm going to rewrite it as
// more modern JS so I can get tsc to help check types.
'use strict'
const Stream = require('stream')
const NoFilter = require('nofilter')
const TransformStream = Stream.Transform
/**
* BinaryParseStream is a TransformStream that consumes buffers and outputs
* objects on the other end. It expects your subclass to implement a `_parse`
* method that is a generator. When your generator yields a number, it'll be
* fed a buffer of that length from the input. When your generator returns,
* the return value will be pushed to the output side.
*
* @class BinaryParseStream
* @extends {TransformStream}
*/
class BinaryParseStream extends TransformStream {
constructor(options) {
super(options)
// doesn't work to pass these in as opts, for some reason
this['_writableState'].objectMode = false
this['_readableState'].objectMode = true
this.bs = new NoFilter()
this.__restart()
}
_transform(fresh, encoding, cb) {
this.bs.write(fresh)
while (this.bs.length >= this.__needed) {
let ret
const chunk = (this.__needed === null) ?
undefined : this.bs.read(this.__needed)
try {
ret = this.__parser.next(chunk)
} catch (e) {
return cb(e)
}
if (this.__needed) {
this.__fresh = false
}
if (!ret.done) {
this.__needed = ret.value || 0
} else {
this.push(ret.value)
this.__restart()
}
}
return cb()
}
/**
* @abstract
*/
/* istanbul ignore next */
*_parse() {
throw new Error('Must be implemented in subclass')
}
__restart() {
this.__needed = null
this.__parser = this._parse()
this.__fresh = true
}
_flush(cb) {
cb(this.__fresh ? null : new Error('unexpected end of input'))
}
}
module.exports = BinaryParseStream