3174 lines
88 KiB
JavaScript
3174 lines
88 KiB
JavaScript
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
var debounce = require('utilise/debounce')
|
|
, escape = require('utilise/escape')
|
|
, noop = require('utilise/noop')
|
|
, raw = require('utilise/raw')
|
|
, to = require('utilise/to')
|
|
, core = require('rijs.core')
|
|
, data = require('rijs.data')
|
|
, sync = require('rijs.sync')
|
|
|
|
var ripple = sync(data(core()))
|
|
, con = window.console
|
|
, log = con ? Function.prototype.bind.call(con.log, con) : noop
|
|
|
|
var html = ''
|
|
, running = true
|
|
, failures = 0
|
|
, passes = 0
|
|
, tests = 0
|
|
, name = 'All Tests'
|
|
, output = raw('pre')
|
|
|
|
// send tests-starting signal
|
|
ripple.send('results', 'SAVE', {
|
|
stats: { running: running }
|
|
, suites: []
|
|
, html: 'Test in progress..'
|
|
})
|
|
|
|
// proxy errors back to terminal
|
|
// window.onerror = (message, url, linenumber) =>
|
|
// ripple.io.emit('global err', message, url, linenumber)
|
|
|
|
// proxy console logs back to terminal
|
|
;['log', 'info', 'warn', 'error', 'debug'].map(function (m) {
|
|
if (!con || !con[m]) { return; } // ie
|
|
var sup = Function.prototype.bind.call(con[m], con)
|
|
window.console[m] = function(){
|
|
var args = to.arr(arguments)
|
|
// ripple.io.emit('console', m, args.map(d => d))
|
|
sup.apply && sup.apply(con, arguments)
|
|
}
|
|
})
|
|
|
|
// stream results back
|
|
var update = debounce(500)(function(){
|
|
var stats = { running: running, tests: tests, passes: passes, failures: failures }
|
|
, suites = [{ name: name, failures: failures, total: tests }]
|
|
|
|
output.innerHTML = html
|
|
ripple.send('results', 'SAVE', { stats: stats, suites: suites, html: html })
|
|
})
|
|
|
|
// listen on log
|
|
;(window.console = window.console || {}).log = function(){
|
|
var line = to.arr(arguments).join(' ')
|
|
html += escape(line) + '\n'
|
|
|
|
if (-1 === includes('# tests')(line)) { running = false }
|
|
if (-1 === includes('ok ')(line)) { passes++; tests++ }
|
|
if (-1 === includes('not ok ')(line)) { failures++; tests++ }
|
|
|
|
if (line.match(/^(?!.*\[ri\/)/)) { update() }
|
|
log.apply(console, arguments)
|
|
}
|
|
|
|
},{"rijs.core":9,"rijs.data":11,"rijs.sync":12,"utilise/debounce":18,"utilise/escape":22,"utilise/noop":35,"utilise/raw":40,"utilise/to":43}],2:[function(require,module,exports){
|
|
var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
|
|
|
|
;(function (exports) {
|
|
'use strict';
|
|
|
|
var Arr = (typeof Uint8Array !== 'undefined')
|
|
? Uint8Array
|
|
: Array
|
|
|
|
var PLUS = '+'.charCodeAt(0)
|
|
var SLASH = '/'.charCodeAt(0)
|
|
var NUMBER = '0'.charCodeAt(0)
|
|
var LOWER = 'a'.charCodeAt(0)
|
|
var UPPER = 'A'.charCodeAt(0)
|
|
var PLUS_URL_SAFE = '-'.charCodeAt(0)
|
|
var SLASH_URL_SAFE = '_'.charCodeAt(0)
|
|
|
|
function decode (elt) {
|
|
var code = elt.charCodeAt(0)
|
|
if (code === PLUS ||
|
|
code === PLUS_URL_SAFE)
|
|
return 62 // '+'
|
|
if (code === SLASH ||
|
|
code === SLASH_URL_SAFE)
|
|
return 63 // '/'
|
|
if (code < NUMBER)
|
|
return -1 //no match
|
|
if (code < NUMBER + 10)
|
|
return code - NUMBER + 26 + 26
|
|
if (code < UPPER + 26)
|
|
return code - UPPER
|
|
if (code < LOWER + 26)
|
|
return code - LOWER + 26
|
|
}
|
|
|
|
function b64ToByteArray (b64) {
|
|
var i, j, l, tmp, placeHolders, arr
|
|
|
|
if (b64.length % 4 > 0) {
|
|
throw new Error('Invalid string. Length must be a multiple of 4')
|
|
}
|
|
|
|
// the number of equal signs (place holders)
|
|
// if there are two placeholders, than the two characters before it
|
|
// represent one byte
|
|
// if there is only one, then the three characters before it represent 2 bytes
|
|
// this is just a cheap hack to not do indexOf twice
|
|
var len = b64.length
|
|
placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0
|
|
|
|
// base64 is 4/3 + up to two characters of the original data
|
|
arr = new Arr(b64.length * 3 / 4 - placeHolders)
|
|
|
|
// if there are placeholders, only get up to the last complete 4 chars
|
|
l = placeHolders > 0 ? b64.length - 4 : b64.length
|
|
|
|
var L = 0
|
|
|
|
function push (v) {
|
|
arr[L++] = v
|
|
}
|
|
|
|
for (i = 0, j = 0; i < l; i += 4, j += 3) {
|
|
tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
|
|
push((tmp & 0xFF0000) >> 16)
|
|
push((tmp & 0xFF00) >> 8)
|
|
push(tmp & 0xFF)
|
|
}
|
|
|
|
if (placeHolders === 2) {
|
|
tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)
|
|
push(tmp & 0xFF)
|
|
} else if (placeHolders === 1) {
|
|
tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
|
|
push((tmp >> 8) & 0xFF)
|
|
push(tmp & 0xFF)
|
|
}
|
|
|
|
return arr
|
|
}
|
|
|
|
function uint8ToBase64 (uint8) {
|
|
var i,
|
|
extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
|
|
output = "",
|
|
temp, length
|
|
|
|
function encode (num) {
|
|
return lookup.charAt(num)
|
|
}
|
|
|
|
function tripletToBase64 (num) {
|
|
return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)
|
|
}
|
|
|
|
// go through the array every three bytes, we'll deal with trailing stuff later
|
|
for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
|
|
temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
|
|
output += tripletToBase64(temp)
|
|
}
|
|
|
|
// pad the end with zeros, but make sure to not forget the extra bytes
|
|
switch (extraBytes) {
|
|
case 1:
|
|
temp = uint8[uint8.length - 1]
|
|
output += encode(temp >> 2)
|
|
output += encode((temp << 4) & 0x3F)
|
|
output += '=='
|
|
break
|
|
case 2:
|
|
temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])
|
|
output += encode(temp >> 10)
|
|
output += encode((temp >> 4) & 0x3F)
|
|
output += encode((temp << 2) & 0x3F)
|
|
output += '='
|
|
break
|
|
}
|
|
|
|
return output
|
|
}
|
|
|
|
exports.toByteArray = b64ToByteArray
|
|
exports.fromByteArray = uint8ToBase64
|
|
}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))
|
|
|
|
},{}],3:[function(require,module,exports){
|
|
|
|
},{}],4:[function(require,module,exports){
|
|
(function (global){
|
|
/*!
|
|
* The buffer module from node.js, for the browser.
|
|
*
|
|
* @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
|
|
* @license MIT
|
|
*/
|
|
/* eslint-disable no-proto */
|
|
|
|
'use strict'
|
|
|
|
var base64 = require('base64-js')
|
|
var ieee754 = require('ieee754')
|
|
var isArray = require('isarray')
|
|
|
|
exports.Buffer = Buffer
|
|
exports.SlowBuffer = SlowBuffer
|
|
exports.INSPECT_MAX_BYTES = 50
|
|
Buffer.poolSize = 8192 // not used by this implementation
|
|
|
|
var rootParent = {}
|
|
|
|
/**
|
|
* If `Buffer.TYPED_ARRAY_SUPPORT`:
|
|
* === true Use Uint8Array implementation (fastest)
|
|
* === false Use Object implementation (most compatible, even IE6)
|
|
*
|
|
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
|
|
* Opera 11.6+, iOS 4.2+.
|
|
*
|
|
* Due to various browser bugs, sometimes the Object implementation will be used even
|
|
* when the browser supports typed arrays.
|
|
*
|
|
* Note:
|
|
*
|
|
* - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
|
|
* See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
|
|
*
|
|
* - Safari 5-7 lacks support for changing the `Object.prototype.constructor` property
|
|
* on objects.
|
|
*
|
|
* - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
|
|
*
|
|
* - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
|
|
* incorrect length in some situations.
|
|
|
|
* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
|
|
* get the Object implementation, which is slower but behaves correctly.
|
|
*/
|
|
Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
|
|
? global.TYPED_ARRAY_SUPPORT
|
|
: typedArraySupport()
|
|
|
|
function typedArraySupport () {
|
|
function Bar () {}
|
|
try {
|
|
var arr = new Uint8Array(1)
|
|
arr.foo = function () { return 42 }
|
|
arr.constructor = Bar
|
|
return arr.foo() === 42 && // typed array instances can be augmented
|
|
arr.constructor === Bar && // constructor can be set
|
|
typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
|
|
arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
|
|
} catch (e) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
function kMaxLength () {
|
|
return Buffer.TYPED_ARRAY_SUPPORT
|
|
? 0x7fffffff
|
|
: 0x3fffffff
|
|
}
|
|
|
|
/**
|
|
* Class: Buffer
|
|
* =============
|
|
*
|
|
* The Buffer constructor returns instances of `Uint8Array` that are augmented
|
|
* with function properties for all the node `Buffer` API functions. We use
|
|
* `Uint8Array` so that square bracket notation works as expected -- it returns
|
|
* a single octet.
|
|
*
|
|
* By augmenting the instances, we can avoid modifying the `Uint8Array`
|
|
* prototype.
|
|
*/
|
|
function Buffer (arg) {
|
|
if (!(this instanceof Buffer)) {
|
|
// Avoid going through an ArgumentsAdaptorTrampoline in the common case.
|
|
if (arguments.length > 1) return new Buffer(arg, arguments[1])
|
|
return new Buffer(arg)
|
|
}
|
|
|
|
if (!Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this.length = 0
|
|
this.parent = undefined
|
|
}
|
|
|
|
// Common case.
|
|
if (typeof arg === 'number') {
|
|
return fromNumber(this, arg)
|
|
}
|
|
|
|
// Slightly less common case.
|
|
if (typeof arg === 'string') {
|
|
return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8')
|
|
}
|
|
|
|
// Unusual.
|
|
return fromObject(this, arg)
|
|
}
|
|
|
|
function fromNumber (that, length) {
|
|
that = allocate(that, length < 0 ? 0 : checked(length) | 0)
|
|
if (!Buffer.TYPED_ARRAY_SUPPORT) {
|
|
for (var i = 0; i < length; i++) {
|
|
that[i] = 0
|
|
}
|
|
}
|
|
return that
|
|
}
|
|
|
|
function fromString (that, string, encoding) {
|
|
if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8'
|
|
|
|
// Assumption: byteLength() return value is always < kMaxLength.
|
|
var length = byteLength(string, encoding) | 0
|
|
that = allocate(that, length)
|
|
|
|
that.write(string, encoding)
|
|
return that
|
|
}
|
|
|
|
function fromObject (that, object) {
|
|
if (Buffer.isBuffer(object)) return fromBuffer(that, object)
|
|
|
|
if (isArray(object)) return fromArray(that, object)
|
|
|
|
if (object == null) {
|
|
throw new TypeError('must start with number, buffer, array or string')
|
|
}
|
|
|
|
if (typeof ArrayBuffer !== 'undefined') {
|
|
if (object.buffer instanceof ArrayBuffer) {
|
|
return fromTypedArray(that, object)
|
|
}
|
|
if (object instanceof ArrayBuffer) {
|
|
return fromArrayBuffer(that, object)
|
|
}
|
|
}
|
|
|
|
if (object.length) return fromArrayLike(that, object)
|
|
|
|
return fromJsonObject(that, object)
|
|
}
|
|
|
|
function fromBuffer (that, buffer) {
|
|
var length = checked(buffer.length) | 0
|
|
that = allocate(that, length)
|
|
buffer.copy(that, 0, 0, length)
|
|
return that
|
|
}
|
|
|
|
function fromArray (that, array) {
|
|
var length = checked(array.length) | 0
|
|
that = allocate(that, length)
|
|
for (var i = 0; i < length; i += 1) {
|
|
that[i] = array[i] & 255
|
|
}
|
|
return that
|
|
}
|
|
|
|
// Duplicate of fromArray() to keep fromArray() monomorphic.
|
|
function fromTypedArray (that, array) {
|
|
var length = checked(array.length) | 0
|
|
that = allocate(that, length)
|
|
// Truncating the elements is probably not what people expect from typed
|
|
// arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior
|
|
// of the old Buffer constructor.
|
|
for (var i = 0; i < length; i += 1) {
|
|
that[i] = array[i] & 255
|
|
}
|
|
return that
|
|
}
|
|
|
|
function fromArrayBuffer (that, array) {
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
// Return an augmented `Uint8Array` instance, for best performance
|
|
array.byteLength
|
|
that = Buffer._augment(new Uint8Array(array))
|
|
} else {
|
|
// Fallback: Return an object instance of the Buffer class
|
|
that = fromTypedArray(that, new Uint8Array(array))
|
|
}
|
|
return that
|
|
}
|
|
|
|
function fromArrayLike (that, array) {
|
|
var length = checked(array.length) | 0
|
|
that = allocate(that, length)
|
|
for (var i = 0; i < length; i += 1) {
|
|
that[i] = array[i] & 255
|
|
}
|
|
return that
|
|
}
|
|
|
|
// Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object.
|
|
// Returns a zero-length buffer for inputs that don't conform to the spec.
|
|
function fromJsonObject (that, object) {
|
|
var array
|
|
var length = 0
|
|
|
|
if (object.type === 'Buffer' && isArray(object.data)) {
|
|
array = object.data
|
|
length = checked(array.length) | 0
|
|
}
|
|
that = allocate(that, length)
|
|
|
|
for (var i = 0; i < length; i += 1) {
|
|
that[i] = array[i] & 255
|
|
}
|
|
return that
|
|
}
|
|
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
Buffer.prototype.__proto__ = Uint8Array.prototype
|
|
Buffer.__proto__ = Uint8Array
|
|
} else {
|
|
// pre-set for values that may exist in the future
|
|
Buffer.prototype.length = undefined
|
|
Buffer.prototype.parent = undefined
|
|
}
|
|
|
|
function allocate (that, length) {
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
// Return an augmented `Uint8Array` instance, for best performance
|
|
that = Buffer._augment(new Uint8Array(length))
|
|
that.__proto__ = Buffer.prototype
|
|
} else {
|
|
// Fallback: Return an object instance of the Buffer class
|
|
that.length = length
|
|
that._isBuffer = true
|
|
}
|
|
|
|
var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1
|
|
if (fromPool) that.parent = rootParent
|
|
|
|
return that
|
|
}
|
|
|
|
function checked (length) {
|
|
// Note: cannot use `length < kMaxLength` here because that fails when
|
|
// length is NaN (which is otherwise coerced to zero.)
|
|
if (length >= kMaxLength()) {
|
|
throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
|
|
'size: 0x' + kMaxLength().toString(16) + ' bytes')
|
|
}
|
|
return length | 0
|
|
}
|
|
|
|
function SlowBuffer (subject, encoding) {
|
|
if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding)
|
|
|
|
var buf = new Buffer(subject, encoding)
|
|
delete buf.parent
|
|
return buf
|
|
}
|
|
|
|
Buffer.isBuffer = function isBuffer (b) {
|
|
return !!(b != null && b._isBuffer)
|
|
}
|
|
|
|
Buffer.compare = function compare (a, b) {
|
|
if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
|
|
throw new TypeError('Arguments must be Buffers')
|
|
}
|
|
|
|
if (a === b) return 0
|
|
|
|
var x = a.length
|
|
var y = b.length
|
|
|
|
var i = 0
|
|
var len = Math.min(x, y)
|
|
while (i < len) {
|
|
if (a[i] !== b[i]) break
|
|
|
|
++i
|
|
}
|
|
|
|
if (i !== len) {
|
|
x = a[i]
|
|
y = b[i]
|
|
}
|
|
|
|
if (x < y) return -1
|
|
if (y < x) return 1
|
|
return 0
|
|
}
|
|
|
|
Buffer.isEncoding = function isEncoding (encoding) {
|
|
switch (String(encoding).toLowerCase()) {
|
|
case 'hex':
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
case 'ascii':
|
|
case 'binary':
|
|
case 'base64':
|
|
case 'raw':
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
Buffer.concat = function concat (list, length) {
|
|
if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.')
|
|
|
|
if (list.length === 0) {
|
|
return new Buffer(0)
|
|
}
|
|
|
|
var i
|
|
if (length === undefined) {
|
|
length = 0
|
|
for (i = 0; i < list.length; i++) {
|
|
length += list[i].length
|
|
}
|
|
}
|
|
|
|
var buf = new Buffer(length)
|
|
var pos = 0
|
|
for (i = 0; i < list.length; i++) {
|
|
var item = list[i]
|
|
item.copy(buf, pos)
|
|
pos += item.length
|
|
}
|
|
return buf
|
|
}
|
|
|
|
function byteLength (string, encoding) {
|
|
if (typeof string !== 'string') string = '' + string
|
|
|
|
var len = string.length
|
|
if (len === 0) return 0
|
|
|
|
// Use a for loop to avoid recursion
|
|
var loweredCase = false
|
|
for (;;) {
|
|
switch (encoding) {
|
|
case 'ascii':
|
|
case 'binary':
|
|
// Deprecated
|
|
case 'raw':
|
|
case 'raws':
|
|
return len
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
return utf8ToBytes(string).length
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return len * 2
|
|
case 'hex':
|
|
return len >>> 1
|
|
case 'base64':
|
|
return base64ToBytes(string).length
|
|
default:
|
|
if (loweredCase) return utf8ToBytes(string).length // assume utf8
|
|
encoding = ('' + encoding).toLowerCase()
|
|
loweredCase = true
|
|
}
|
|
}
|
|
}
|
|
Buffer.byteLength = byteLength
|
|
|
|
function slowToString (encoding, start, end) {
|
|
var loweredCase = false
|
|
|
|
start = start | 0
|
|
end = end === undefined || end === Infinity ? this.length : end | 0
|
|
|
|
if (!encoding) encoding = 'utf8'
|
|
if (start < 0) start = 0
|
|
if (end > this.length) end = this.length
|
|
if (end <= start) return ''
|
|
|
|
while (true) {
|
|
switch (encoding) {
|
|
case 'hex':
|
|
return hexSlice(this, start, end)
|
|
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
return utf8Slice(this, start, end)
|
|
|
|
case 'ascii':
|
|
return asciiSlice(this, start, end)
|
|
|
|
case 'binary':
|
|
return binarySlice(this, start, end)
|
|
|
|
case 'base64':
|
|
return base64Slice(this, start, end)
|
|
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return utf16leSlice(this, start, end)
|
|
|
|
default:
|
|
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
|
|
encoding = (encoding + '').toLowerCase()
|
|
loweredCase = true
|
|
}
|
|
}
|
|
}
|
|
|
|
Buffer.prototype.toString = function toString () {
|
|
var length = this.length | 0
|
|
if (length === 0) return ''
|
|
if (arguments.length === 0) return utf8Slice(this, 0, length)
|
|
return slowToString.apply(this, arguments)
|
|
}
|
|
|
|
Buffer.prototype.equals = function equals (b) {
|
|
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
|
|
if (this === b) return true
|
|
return Buffer.compare(this, b) === 0
|
|
}
|
|
|
|
Buffer.prototype.inspect = function inspect () {
|
|
var str = ''
|
|
var max = exports.INSPECT_MAX_BYTES
|
|
if (this.length > 0) {
|
|
str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
|
|
if (this.length > max) str += ' ... '
|
|
}
|
|
return '<Buffer ' + str + '>'
|
|
}
|
|
|
|
Buffer.prototype.compare = function compare (b) {
|
|
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
|
|
if (this === b) return 0
|
|
return Buffer.compare(this, b)
|
|
}
|
|
|
|
Buffer.prototype.indexOf = function indexOf (val, byteOffset) {
|
|
if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff
|
|
else if (byteOffset < -0x80000000) byteOffset = -0x80000000
|
|
byteOffset >>= 0
|
|
|
|
if (this.length === 0) return -1
|
|
if (byteOffset >= this.length) return -1
|
|
|
|
// Negative offsets start from the end of the buffer
|
|
if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0)
|
|
|
|
if (typeof val === 'string') {
|
|
if (val.length === 0) return -1 // special case: looking for empty string always fails
|
|
return String.prototype.indexOf.call(this, val, byteOffset)
|
|
}
|
|
if (Buffer.isBuffer(val)) {
|
|
return arrayIndexOf(this, val, byteOffset)
|
|
}
|
|
if (typeof val === 'number') {
|
|
if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') {
|
|
return Uint8Array.prototype.indexOf.call(this, val, byteOffset)
|
|
}
|
|
return arrayIndexOf(this, [ val ], byteOffset)
|
|
}
|
|
|
|
function arrayIndexOf (arr, val, byteOffset) {
|
|
var foundIndex = -1
|
|
for (var i = 0; byteOffset + i < arr.length; i++) {
|
|
if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) {
|
|
if (foundIndex === -1) foundIndex = i
|
|
if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex
|
|
} else {
|
|
foundIndex = -1
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
|
|
throw new TypeError('val must be string, number or Buffer')
|
|
}
|
|
|
|
// `get` is deprecated
|
|
Buffer.prototype.get = function get (offset) {
|
|
console.log('.get() is deprecated. Access using array indexes instead.')
|
|
return this.readUInt8(offset)
|
|
}
|
|
|
|
// `set` is deprecated
|
|
Buffer.prototype.set = function set (v, offset) {
|
|
console.log('.set() is deprecated. Access using array indexes instead.')
|
|
return this.writeUInt8(v, offset)
|
|
}
|
|
|
|
function hexWrite (buf, string, offset, length) {
|
|
offset = Number(offset) || 0
|
|
var remaining = buf.length - offset
|
|
if (!length) {
|
|
length = remaining
|
|
} else {
|
|
length = Number(length)
|
|
if (length > remaining) {
|
|
length = remaining
|
|
}
|
|
}
|
|
|
|
// must be an even number of digits
|
|
var strLen = string.length
|
|
if (strLen % 2 !== 0) throw new Error('Invalid hex string')
|
|
|
|
if (length > strLen / 2) {
|
|
length = strLen / 2
|
|
}
|
|
for (var i = 0; i < length; i++) {
|
|
var parsed = parseInt(string.substr(i * 2, 2), 16)
|
|
if (isNaN(parsed)) throw new Error('Invalid hex string')
|
|
buf[offset + i] = parsed
|
|
}
|
|
return i
|
|
}
|
|
|
|
function utf8Write (buf, string, offset, length) {
|
|
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
|
|
}
|
|
|
|
function asciiWrite (buf, string, offset, length) {
|
|
return blitBuffer(asciiToBytes(string), buf, offset, length)
|
|
}
|
|
|
|
function binaryWrite (buf, string, offset, length) {
|
|
return asciiWrite(buf, string, offset, length)
|
|
}
|
|
|
|
function base64Write (buf, string, offset, length) {
|
|
return blitBuffer(base64ToBytes(string), buf, offset, length)
|
|
}
|
|
|
|
function ucs2Write (buf, string, offset, length) {
|
|
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
|
|
}
|
|
|
|
Buffer.prototype.write = function write (string, offset, length, encoding) {
|
|
// Buffer#write(string)
|
|
if (offset === undefined) {
|
|
encoding = 'utf8'
|
|
length = this.length
|
|
offset = 0
|
|
// Buffer#write(string, encoding)
|
|
} else if (length === undefined && typeof offset === 'string') {
|
|
encoding = offset
|
|
length = this.length
|
|
offset = 0
|
|
// Buffer#write(string, offset[, length][, encoding])
|
|
} else if (isFinite(offset)) {
|
|
offset = offset | 0
|
|
if (isFinite(length)) {
|
|
length = length | 0
|
|
if (encoding === undefined) encoding = 'utf8'
|
|
} else {
|
|
encoding = length
|
|
length = undefined
|
|
}
|
|
// legacy write(string, encoding, offset, length) - remove in v0.13
|
|
} else {
|
|
var swap = encoding
|
|
encoding = offset
|
|
offset = length | 0
|
|
length = swap
|
|
}
|
|
|
|
var remaining = this.length - offset
|
|
if (length === undefined || length > remaining) length = remaining
|
|
|
|
if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
|
|
throw new RangeError('attempt to write outside buffer bounds')
|
|
}
|
|
|
|
if (!encoding) encoding = 'utf8'
|
|
|
|
var loweredCase = false
|
|
for (;;) {
|
|
switch (encoding) {
|
|
case 'hex':
|
|
return hexWrite(this, string, offset, length)
|
|
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
return utf8Write(this, string, offset, length)
|
|
|
|
case 'ascii':
|
|
return asciiWrite(this, string, offset, length)
|
|
|
|
case 'binary':
|
|
return binaryWrite(this, string, offset, length)
|
|
|
|
case 'base64':
|
|
// Warning: maxLength not taken into account in base64Write
|
|
return base64Write(this, string, offset, length)
|
|
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return ucs2Write(this, string, offset, length)
|
|
|
|
default:
|
|
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
|
|
encoding = ('' + encoding).toLowerCase()
|
|
loweredCase = true
|
|
}
|
|
}
|
|
}
|
|
|
|
Buffer.prototype.toJSON = function toJSON () {
|
|
return {
|
|
type: 'Buffer',
|
|
data: Array.prototype.slice.call(this._arr || this, 0)
|
|
}
|
|
}
|
|
|
|
function base64Slice (buf, start, end) {
|
|
if (start === 0 && end === buf.length) {
|
|
return base64.fromByteArray(buf)
|
|
} else {
|
|
return base64.fromByteArray(buf.slice(start, end))
|
|
}
|
|
}
|
|
|
|
function utf8Slice (buf, start, end) {
|
|
end = Math.min(buf.length, end)
|
|
var res = []
|
|
|
|
var i = start
|
|
while (i < end) {
|
|
var firstByte = buf[i]
|
|
var codePoint = null
|
|
var bytesPerSequence = (firstByte > 0xEF) ? 4
|
|
: (firstByte > 0xDF) ? 3
|
|
: (firstByte > 0xBF) ? 2
|
|
: 1
|
|
|
|
if (i + bytesPerSequence <= end) {
|
|
var secondByte, thirdByte, fourthByte, tempCodePoint
|
|
|
|
switch (bytesPerSequence) {
|
|
case 1:
|
|
if (firstByte < 0x80) {
|
|
codePoint = firstByte
|
|
}
|
|
break
|
|
case 2:
|
|
secondByte = buf[i + 1]
|
|
if ((secondByte & 0xC0) === 0x80) {
|
|
tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
|
|
if (tempCodePoint > 0x7F) {
|
|
codePoint = tempCodePoint
|
|
}
|
|
}
|
|
break
|
|
case 3:
|
|
secondByte = buf[i + 1]
|
|
thirdByte = buf[i + 2]
|
|
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
|
|
tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
|
|
if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
|
|
codePoint = tempCodePoint
|
|
}
|
|
}
|
|
break
|
|
case 4:
|
|
secondByte = buf[i + 1]
|
|
thirdByte = buf[i + 2]
|
|
fourthByte = buf[i + 3]
|
|
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
|
|
tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
|
|
if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
|
|
codePoint = tempCodePoint
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (codePoint === null) {
|
|
// we did not generate a valid codePoint so insert a
|
|
// replacement char (U+FFFD) and advance only 1 byte
|
|
codePoint = 0xFFFD
|
|
bytesPerSequence = 1
|
|
} else if (codePoint > 0xFFFF) {
|
|
// encode to utf16 (surrogate pair dance)
|
|
codePoint -= 0x10000
|
|
res.push(codePoint >>> 10 & 0x3FF | 0xD800)
|
|
codePoint = 0xDC00 | codePoint & 0x3FF
|
|
}
|
|
|
|
res.push(codePoint)
|
|
i += bytesPerSequence
|
|
}
|
|
|
|
return decodeCodePointsArray(res)
|
|
}
|
|
|
|
// Based on http://stackoverflow.com/a/22747272/680742, the browser with
|
|
// the lowest limit is Chrome, with 0x10000 args.
|
|
// We go 1 magnitude less, for safety
|
|
var MAX_ARGUMENTS_LENGTH = 0x1000
|
|
|
|
function decodeCodePointsArray (codePoints) {
|
|
var len = codePoints.length
|
|
if (len <= MAX_ARGUMENTS_LENGTH) {
|
|
return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
|
|
}
|
|
|
|
// Decode in chunks to avoid "call stack size exceeded".
|
|
var res = ''
|
|
var i = 0
|
|
while (i < len) {
|
|
res += String.fromCharCode.apply(
|
|
String,
|
|
codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
|
|
)
|
|
}
|
|
return res
|
|
}
|
|
|
|
function asciiSlice (buf, start, end) {
|
|
var ret = ''
|
|
end = Math.min(buf.length, end)
|
|
|
|
for (var i = start; i < end; i++) {
|
|
ret += String.fromCharCode(buf[i] & 0x7F)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
function binarySlice (buf, start, end) {
|
|
var ret = ''
|
|
end = Math.min(buf.length, end)
|
|
|
|
for (var i = start; i < end; i++) {
|
|
ret += String.fromCharCode(buf[i])
|
|
}
|
|
return ret
|
|
}
|
|
|
|
function hexSlice (buf, start, end) {
|
|
var len = buf.length
|
|
|
|
if (!start || start < 0) start = 0
|
|
if (!end || end < 0 || end > len) end = len
|
|
|
|
var out = ''
|
|
for (var i = start; i < end; i++) {
|
|
out += toHex(buf[i])
|
|
}
|
|
return out
|
|
}
|
|
|
|
function utf16leSlice (buf, start, end) {
|
|
var bytes = buf.slice(start, end)
|
|
var res = ''
|
|
for (var i = 0; i < bytes.length; i += 2) {
|
|
res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
|
|
}
|
|
return res
|
|
}
|
|
|
|
Buffer.prototype.slice = function slice (start, end) {
|
|
var len = this.length
|
|
start = ~~start
|
|
end = end === undefined ? len : ~~end
|
|
|
|
if (start < 0) {
|
|
start += len
|
|
if (start < 0) start = 0
|
|
} else if (start > len) {
|
|
start = len
|
|
}
|
|
|
|
if (end < 0) {
|
|
end += len
|
|
if (end < 0) end = 0
|
|
} else if (end > len) {
|
|
end = len
|
|
}
|
|
|
|
if (end < start) end = start
|
|
|
|
var newBuf
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
newBuf = Buffer._augment(this.subarray(start, end))
|
|
} else {
|
|
var sliceLen = end - start
|
|
newBuf = new Buffer(sliceLen, undefined)
|
|
for (var i = 0; i < sliceLen; i++) {
|
|
newBuf[i] = this[i + start]
|
|
}
|
|
}
|
|
|
|
if (newBuf.length) newBuf.parent = this.parent || this
|
|
|
|
return newBuf
|
|
}
|
|
|
|
/*
|
|
* Need to make sure that buffer isn't trying to write out of bounds.
|
|
*/
|
|
function checkOffset (offset, ext, length) {
|
|
if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
|
|
if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
|
|
}
|
|
|
|
Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
|
|
offset = offset | 0
|
|
byteLength = byteLength | 0
|
|
if (!noAssert) checkOffset(offset, byteLength, this.length)
|
|
|
|
var val = this[offset]
|
|
var mul = 1
|
|
var i = 0
|
|
while (++i < byteLength && (mul *= 0x100)) {
|
|
val += this[offset + i] * mul
|
|
}
|
|
|
|
return val
|
|
}
|
|
|
|
Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
|
|
offset = offset | 0
|
|
byteLength = byteLength | 0
|
|
if (!noAssert) {
|
|
checkOffset(offset, byteLength, this.length)
|
|
}
|
|
|
|
var val = this[offset + --byteLength]
|
|
var mul = 1
|
|
while (byteLength > 0 && (mul *= 0x100)) {
|
|
val += this[offset + --byteLength] * mul
|
|
}
|
|
|
|
return val
|
|
}
|
|
|
|
Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 1, this.length)
|
|
return this[offset]
|
|
}
|
|
|
|
Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
|
return this[offset] | (this[offset + 1] << 8)
|
|
}
|
|
|
|
Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
|
return (this[offset] << 8) | this[offset + 1]
|
|
}
|
|
|
|
Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
|
|
return ((this[offset]) |
|
|
(this[offset + 1] << 8) |
|
|
(this[offset + 2] << 16)) +
|
|
(this[offset + 3] * 0x1000000)
|
|
}
|
|
|
|
Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
|
|
return (this[offset] * 0x1000000) +
|
|
((this[offset + 1] << 16) |
|
|
(this[offset + 2] << 8) |
|
|
this[offset + 3])
|
|
}
|
|
|
|
Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
|
|
offset = offset | 0
|
|
byteLength = byteLength | 0
|
|
if (!noAssert) checkOffset(offset, byteLength, this.length)
|
|
|
|
var val = this[offset]
|
|
var mul = 1
|
|
var i = 0
|
|
while (++i < byteLength && (mul *= 0x100)) {
|
|
val += this[offset + i] * mul
|
|
}
|
|
mul *= 0x80
|
|
|
|
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
|
|
|
|
return val
|
|
}
|
|
|
|
Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
|
|
offset = offset | 0
|
|
byteLength = byteLength | 0
|
|
if (!noAssert) checkOffset(offset, byteLength, this.length)
|
|
|
|
var i = byteLength
|
|
var mul = 1
|
|
var val = this[offset + --i]
|
|
while (i > 0 && (mul *= 0x100)) {
|
|
val += this[offset + --i] * mul
|
|
}
|
|
mul *= 0x80
|
|
|
|
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
|
|
|
|
return val
|
|
}
|
|
|
|
Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 1, this.length)
|
|
if (!(this[offset] & 0x80)) return (this[offset])
|
|
return ((0xff - this[offset] + 1) * -1)
|
|
}
|
|
|
|
Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
|
var val = this[offset] | (this[offset + 1] << 8)
|
|
return (val & 0x8000) ? val | 0xFFFF0000 : val
|
|
}
|
|
|
|
Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
|
var val = this[offset + 1] | (this[offset] << 8)
|
|
return (val & 0x8000) ? val | 0xFFFF0000 : val
|
|
}
|
|
|
|
Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
|
|
return (this[offset]) |
|
|
(this[offset + 1] << 8) |
|
|
(this[offset + 2] << 16) |
|
|
(this[offset + 3] << 24)
|
|
}
|
|
|
|
Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
|
|
return (this[offset] << 24) |
|
|
(this[offset + 1] << 16) |
|
|
(this[offset + 2] << 8) |
|
|
(this[offset + 3])
|
|
}
|
|
|
|
Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
return ieee754.read(this, offset, true, 23, 4)
|
|
}
|
|
|
|
Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
return ieee754.read(this, offset, false, 23, 4)
|
|
}
|
|
|
|
Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 8, this.length)
|
|
return ieee754.read(this, offset, true, 52, 8)
|
|
}
|
|
|
|
Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 8, this.length)
|
|
return ieee754.read(this, offset, false, 52, 8)
|
|
}
|
|
|
|
function checkInt (buf, value, offset, ext, max, min) {
|
|
if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance')
|
|
if (value > max || value < min) throw new RangeError('value is out of bounds')
|
|
if (offset + ext > buf.length) throw new RangeError('index out of range')
|
|
}
|
|
|
|
Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
byteLength = byteLength | 0
|
|
if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
|
|
|
|
var mul = 1
|
|
var i = 0
|
|
this[offset] = value & 0xFF
|
|
while (++i < byteLength && (mul *= 0x100)) {
|
|
this[offset + i] = (value / mul) & 0xFF
|
|
}
|
|
|
|
return offset + byteLength
|
|
}
|
|
|
|
Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
byteLength = byteLength | 0
|
|
if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
|
|
|
|
var i = byteLength - 1
|
|
var mul = 1
|
|
this[offset + i] = value & 0xFF
|
|
while (--i >= 0 && (mul *= 0x100)) {
|
|
this[offset + i] = (value / mul) & 0xFF
|
|
}
|
|
|
|
return offset + byteLength
|
|
}
|
|
|
|
Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
|
|
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
|
|
this[offset] = (value & 0xff)
|
|
return offset + 1
|
|
}
|
|
|
|
function objectWriteUInt16 (buf, value, offset, littleEndian) {
|
|
if (value < 0) value = 0xffff + value + 1
|
|
for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {
|
|
buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
|
|
(littleEndian ? i : 1 - i) * 8
|
|
}
|
|
}
|
|
|
|
Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value & 0xff)
|
|
this[offset + 1] = (value >>> 8)
|
|
} else {
|
|
objectWriteUInt16(this, value, offset, true)
|
|
}
|
|
return offset + 2
|
|
}
|
|
|
|
Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value >>> 8)
|
|
this[offset + 1] = (value & 0xff)
|
|
} else {
|
|
objectWriteUInt16(this, value, offset, false)
|
|
}
|
|
return offset + 2
|
|
}
|
|
|
|
function objectWriteUInt32 (buf, value, offset, littleEndian) {
|
|
if (value < 0) value = 0xffffffff + value + 1
|
|
for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {
|
|
buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
|
|
}
|
|
}
|
|
|
|
Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset + 3] = (value >>> 24)
|
|
this[offset + 2] = (value >>> 16)
|
|
this[offset + 1] = (value >>> 8)
|
|
this[offset] = (value & 0xff)
|
|
} else {
|
|
objectWriteUInt32(this, value, offset, true)
|
|
}
|
|
return offset + 4
|
|
}
|
|
|
|
Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value >>> 24)
|
|
this[offset + 1] = (value >>> 16)
|
|
this[offset + 2] = (value >>> 8)
|
|
this[offset + 3] = (value & 0xff)
|
|
} else {
|
|
objectWriteUInt32(this, value, offset, false)
|
|
}
|
|
return offset + 4
|
|
}
|
|
|
|
Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) {
|
|
var limit = Math.pow(2, 8 * byteLength - 1)
|
|
|
|
checkInt(this, value, offset, byteLength, limit - 1, -limit)
|
|
}
|
|
|
|
var i = 0
|
|
var mul = 1
|
|
var sub = value < 0 ? 1 : 0
|
|
this[offset] = value & 0xFF
|
|
while (++i < byteLength && (mul *= 0x100)) {
|
|
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
|
|
}
|
|
|
|
return offset + byteLength
|
|
}
|
|
|
|
Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) {
|
|
var limit = Math.pow(2, 8 * byteLength - 1)
|
|
|
|
checkInt(this, value, offset, byteLength, limit - 1, -limit)
|
|
}
|
|
|
|
var i = byteLength - 1
|
|
var mul = 1
|
|
var sub = value < 0 ? 1 : 0
|
|
this[offset + i] = value & 0xFF
|
|
while (--i >= 0 && (mul *= 0x100)) {
|
|
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
|
|
}
|
|
|
|
return offset + byteLength
|
|
}
|
|
|
|
Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
|
|
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
|
|
if (value < 0) value = 0xff + value + 1
|
|
this[offset] = (value & 0xff)
|
|
return offset + 1
|
|
}
|
|
|
|
Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value & 0xff)
|
|
this[offset + 1] = (value >>> 8)
|
|
} else {
|
|
objectWriteUInt16(this, value, offset, true)
|
|
}
|
|
return offset + 2
|
|
}
|
|
|
|
Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value >>> 8)
|
|
this[offset + 1] = (value & 0xff)
|
|
} else {
|
|
objectWriteUInt16(this, value, offset, false)
|
|
}
|
|
return offset + 2
|
|
}
|
|
|
|
Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value & 0xff)
|
|
this[offset + 1] = (value >>> 8)
|
|
this[offset + 2] = (value >>> 16)
|
|
this[offset + 3] = (value >>> 24)
|
|
} else {
|
|
objectWriteUInt32(this, value, offset, true)
|
|
}
|
|
return offset + 4
|
|
}
|
|
|
|
Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
|
|
if (value < 0) value = 0xffffffff + value + 1
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value >>> 24)
|
|
this[offset + 1] = (value >>> 16)
|
|
this[offset + 2] = (value >>> 8)
|
|
this[offset + 3] = (value & 0xff)
|
|
} else {
|
|
objectWriteUInt32(this, value, offset, false)
|
|
}
|
|
return offset + 4
|
|
}
|
|
|
|
function checkIEEE754 (buf, value, offset, ext, max, min) {
|
|
if (value > max || value < min) throw new RangeError('value is out of bounds')
|
|
if (offset + ext > buf.length) throw new RangeError('index out of range')
|
|
if (offset < 0) throw new RangeError('index out of range')
|
|
}
|
|
|
|
function writeFloat (buf, value, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
|
|
}
|
|
ieee754.write(buf, value, offset, littleEndian, 23, 4)
|
|
return offset + 4
|
|
}
|
|
|
|
Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
|
|
return writeFloat(this, value, offset, true, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
|
|
return writeFloat(this, value, offset, false, noAssert)
|
|
}
|
|
|
|
function writeDouble (buf, value, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
|
|
}
|
|
ieee754.write(buf, value, offset, littleEndian, 52, 8)
|
|
return offset + 8
|
|
}
|
|
|
|
Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
|
|
return writeDouble(this, value, offset, true, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
|
|
return writeDouble(this, value, offset, false, noAssert)
|
|
}
|
|
|
|
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
|
|
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
|
|
if (!start) start = 0
|
|
if (!end && end !== 0) end = this.length
|
|
if (targetStart >= target.length) targetStart = target.length
|
|
if (!targetStart) targetStart = 0
|
|
if (end > 0 && end < start) end = start
|
|
|
|
// Copy 0 bytes; we're done
|
|
if (end === start) return 0
|
|
if (target.length === 0 || this.length === 0) return 0
|
|
|
|
// Fatal error conditions
|
|
if (targetStart < 0) {
|
|
throw new RangeError('targetStart out of bounds')
|
|
}
|
|
if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
|
|
if (end < 0) throw new RangeError('sourceEnd out of bounds')
|
|
|
|
// Are we oob?
|
|
if (end > this.length) end = this.length
|
|
if (target.length - targetStart < end - start) {
|
|
end = target.length - targetStart + start
|
|
}
|
|
|
|
var len = end - start
|
|
var i
|
|
|
|
if (this === target && start < targetStart && targetStart < end) {
|
|
// descending copy from end
|
|
for (i = len - 1; i >= 0; i--) {
|
|
target[i + targetStart] = this[i + start]
|
|
}
|
|
} else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
|
|
// ascending copy from start
|
|
for (i = 0; i < len; i++) {
|
|
target[i + targetStart] = this[i + start]
|
|
}
|
|
} else {
|
|
target._set(this.subarray(start, start + len), targetStart)
|
|
}
|
|
|
|
return len
|
|
}
|
|
|
|
// fill(value, start=0, end=buffer.length)
|
|
Buffer.prototype.fill = function fill (value, start, end) {
|
|
if (!value) value = 0
|
|
if (!start) start = 0
|
|
if (!end) end = this.length
|
|
|
|
if (end < start) throw new RangeError('end < start')
|
|
|
|
// Fill 0 bytes; we're done
|
|
if (end === start) return
|
|
if (this.length === 0) return
|
|
|
|
if (start < 0 || start >= this.length) throw new RangeError('start out of bounds')
|
|
if (end < 0 || end > this.length) throw new RangeError('end out of bounds')
|
|
|
|
var i
|
|
if (typeof value === 'number') {
|
|
for (i = start; i < end; i++) {
|
|
this[i] = value
|
|
}
|
|
} else {
|
|
var bytes = utf8ToBytes(value.toString())
|
|
var len = bytes.length
|
|
for (i = start; i < end; i++) {
|
|
this[i] = bytes[i % len]
|
|
}
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
|
|
* Added in Node 0.12. Only available in browsers that support ArrayBuffer.
|
|
*/
|
|
Buffer.prototype.toArrayBuffer = function toArrayBuffer () {
|
|
if (typeof Uint8Array !== 'undefined') {
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
return (new Buffer(this)).buffer
|
|
} else {
|
|
var buf = new Uint8Array(this.length)
|
|
for (var i = 0, len = buf.length; i < len; i += 1) {
|
|
buf[i] = this[i]
|
|
}
|
|
return buf.buffer
|
|
}
|
|
} else {
|
|
throw new TypeError('Buffer.toArrayBuffer not supported in this browser')
|
|
}
|
|
}
|
|
|
|
// HELPER FUNCTIONS
|
|
// ================
|
|
|
|
var BP = Buffer.prototype
|
|
|
|
/**
|
|
* Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods
|
|
*/
|
|
Buffer._augment = function _augment (arr) {
|
|
arr.constructor = Buffer
|
|
arr._isBuffer = true
|
|
|
|
// save reference to original Uint8Array set method before overwriting
|
|
arr._set = arr.set
|
|
|
|
// deprecated
|
|
arr.get = BP.get
|
|
arr.set = BP.set
|
|
|
|
arr.write = BP.write
|
|
arr.toString = BP.toString
|
|
arr.toLocaleString = BP.toString
|
|
arr.toJSON = BP.toJSON
|
|
arr.equals = BP.equals
|
|
arr.compare = BP.compare
|
|
arr.indexOf = BP.indexOf
|
|
arr.copy = BP.copy
|
|
arr.slice = BP.slice
|
|
arr.readUIntLE = BP.readUIntLE
|
|
arr.readUIntBE = BP.readUIntBE
|
|
arr.readUInt8 = BP.readUInt8
|
|
arr.readUInt16LE = BP.readUInt16LE
|
|
arr.readUInt16BE = BP.readUInt16BE
|
|
arr.readUInt32LE = BP.readUInt32LE
|
|
arr.readUInt32BE = BP.readUInt32BE
|
|
arr.readIntLE = BP.readIntLE
|
|
arr.readIntBE = BP.readIntBE
|
|
arr.readInt8 = BP.readInt8
|
|
arr.readInt16LE = BP.readInt16LE
|
|
arr.readInt16BE = BP.readInt16BE
|
|
arr.readInt32LE = BP.readInt32LE
|
|
arr.readInt32BE = BP.readInt32BE
|
|
arr.readFloatLE = BP.readFloatLE
|
|
arr.readFloatBE = BP.readFloatBE
|
|
arr.readDoubleLE = BP.readDoubleLE
|
|
arr.readDoubleBE = BP.readDoubleBE
|
|
arr.writeUInt8 = BP.writeUInt8
|
|
arr.writeUIntLE = BP.writeUIntLE
|
|
arr.writeUIntBE = BP.writeUIntBE
|
|
arr.writeUInt16LE = BP.writeUInt16LE
|
|
arr.writeUInt16BE = BP.writeUInt16BE
|
|
arr.writeUInt32LE = BP.writeUInt32LE
|
|
arr.writeUInt32BE = BP.writeUInt32BE
|
|
arr.writeIntLE = BP.writeIntLE
|
|
arr.writeIntBE = BP.writeIntBE
|
|
arr.writeInt8 = BP.writeInt8
|
|
arr.writeInt16LE = BP.writeInt16LE
|
|
arr.writeInt16BE = BP.writeInt16BE
|
|
arr.writeInt32LE = BP.writeInt32LE
|
|
arr.writeInt32BE = BP.writeInt32BE
|
|
arr.writeFloatLE = BP.writeFloatLE
|
|
arr.writeFloatBE = BP.writeFloatBE
|
|
arr.writeDoubleLE = BP.writeDoubleLE
|
|
arr.writeDoubleBE = BP.writeDoubleBE
|
|
arr.fill = BP.fill
|
|
arr.inspect = BP.inspect
|
|
arr.toArrayBuffer = BP.toArrayBuffer
|
|
|
|
return arr
|
|
}
|
|
|
|
var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
|
|
|
|
function base64clean (str) {
|
|
// Node strips out invalid characters like \n and \t from the string, base64-js does not
|
|
str = stringtrim(str).replace(INVALID_BASE64_RE, '')
|
|
// Node converts strings with length < 2 to ''
|
|
if (str.length < 2) return ''
|
|
// Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
|
|
while (str.length % 4 !== 0) {
|
|
str = str + '='
|
|
}
|
|
return str
|
|
}
|
|
|
|
function stringtrim (str) {
|
|
if (str.trim) return str.trim()
|
|
return str.replace(/^\s+|\s+$/g, '')
|
|
}
|
|
|
|
function toHex (n) {
|
|
if (n < 16) return '0' + n.toString(16)
|
|
return n.toString(16)
|
|
}
|
|
|
|
function utf8ToBytes (string, units) {
|
|
units = units || Infinity
|
|
var codePoint
|
|
var length = string.length
|
|
var leadSurrogate = null
|
|
var bytes = []
|
|
|
|
for (var i = 0; i < length; i++) {
|
|
codePoint = string.charCodeAt(i)
|
|
|
|
// is surrogate component
|
|
if (codePoint > 0xD7FF && codePoint < 0xE000) {
|
|
// last char was a lead
|
|
if (!leadSurrogate) {
|
|
// no lead yet
|
|
if (codePoint > 0xDBFF) {
|
|
// unexpected trail
|
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
|
|
continue
|
|
} else if (i + 1 === length) {
|
|
// unpaired lead
|
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
|
|
continue
|
|
}
|
|
|
|
// valid lead
|
|
leadSurrogate = codePoint
|
|
|
|
continue
|
|
}
|
|
|
|
// 2 leads in a row
|
|
if (codePoint < 0xDC00) {
|
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
|
|
leadSurrogate = codePoint
|
|
continue
|
|
}
|
|
|
|
// valid surrogate pair
|
|
codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
|
|
} else if (leadSurrogate) {
|
|
// valid bmp char, but last char was a lead
|
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
|
|
}
|
|
|
|
leadSurrogate = null
|
|
|
|
// encode utf8
|
|
if (codePoint < 0x80) {
|
|
if ((units -= 1) < 0) break
|
|
bytes.push(codePoint)
|
|
} else if (codePoint < 0x800) {
|
|
if ((units -= 2) < 0) break
|
|
bytes.push(
|
|
codePoint >> 0x6 | 0xC0,
|
|
codePoint & 0x3F | 0x80
|
|
)
|
|
} else if (codePoint < 0x10000) {
|
|
if ((units -= 3) < 0) break
|
|
bytes.push(
|
|
codePoint >> 0xC | 0xE0,
|
|
codePoint >> 0x6 & 0x3F | 0x80,
|
|
codePoint & 0x3F | 0x80
|
|
)
|
|
} else if (codePoint < 0x110000) {
|
|
if ((units -= 4) < 0) break
|
|
bytes.push(
|
|
codePoint >> 0x12 | 0xF0,
|
|
codePoint >> 0xC & 0x3F | 0x80,
|
|
codePoint >> 0x6 & 0x3F | 0x80,
|
|
codePoint & 0x3F | 0x80
|
|
)
|
|
} else {
|
|
throw new Error('Invalid code point')
|
|
}
|
|
}
|
|
|
|
return bytes
|
|
}
|
|
|
|
function asciiToBytes (str) {
|
|
var byteArray = []
|
|
for (var i = 0; i < str.length; i++) {
|
|
// Node's code seems to be doing this and not & 0x7F..
|
|
byteArray.push(str.charCodeAt(i) & 0xFF)
|
|
}
|
|
return byteArray
|
|
}
|
|
|
|
function utf16leToBytes (str, units) {
|
|
var c, hi, lo
|
|
var byteArray = []
|
|
for (var i = 0; i < str.length; i++) {
|
|
if ((units -= 2) < 0) break
|
|
|
|
c = str.charCodeAt(i)
|
|
hi = c >> 8
|
|
lo = c % 256
|
|
byteArray.push(lo)
|
|
byteArray.push(hi)
|
|
}
|
|
|
|
return byteArray
|
|
}
|
|
|
|
function base64ToBytes (str) {
|
|
return base64.toByteArray(base64clean(str))
|
|
}
|
|
|
|
function blitBuffer (src, dst, offset, length) {
|
|
for (var i = 0; i < length; i++) {
|
|
if ((i + offset >= dst.length) || (i >= src.length)) break
|
|
dst[i + offset] = src[i]
|
|
}
|
|
return i
|
|
}
|
|
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"base64-js":2,"ieee754":7,"isarray":5}],5:[function(require,module,exports){
|
|
var toString = {}.toString;
|
|
|
|
module.exports = Array.isArray || function (arr) {
|
|
return toString.call(arr) == '[object Array]';
|
|
};
|
|
|
|
},{}],6:[function(require,module,exports){
|
|
/**
|
|
* JSON + Object references wrapper
|
|
*
|
|
* @author Hunter Loftis <hunter@skookum.com>
|
|
* @license The MIT license.
|
|
* @copyright Copyright (c) 2010 Skookum, skookum.com
|
|
*/
|
|
|
|
;(function() {
|
|
|
|
var CONTAINER_TYPES = 'object array date function'.split(' ');
|
|
|
|
var REFERENCE_FLAG = '_CRYO_REF_';
|
|
var INFINITY_FLAG = '_CRYO_INFINITY_';
|
|
var FUNCTION_FLAG = '_CRYO_FUNCTION_';
|
|
var UNDEFINED_FLAG = '_CRYO_UNDEFINED_';
|
|
var DATE_FLAG = '_CRYO_DATE_';
|
|
|
|
var OBJECT_FLAG = '_CRYO_OBJECT_';
|
|
var ARRAY_FLAG = '_CRYO_ARRAY_';
|
|
|
|
function typeOf(item) {
|
|
if (typeof item === 'object') {
|
|
if (item === null) return 'null';
|
|
if (item && item.nodeType === 1) return 'dom';
|
|
if (item instanceof Array) return 'array';
|
|
if (item instanceof Date) return 'date';
|
|
return 'object';
|
|
}
|
|
return typeof item;
|
|
}
|
|
|
|
// Same as and copied from _.defaults
|
|
function defaults(obj) {
|
|
var length = arguments.length;
|
|
if (length < 2 || obj == null) return obj;
|
|
for (var index = 1; index < length; index++) {
|
|
var source = arguments[index],
|
|
keys = Object.keys(source),
|
|
l = keys.length;
|
|
for (var i = 0; i < l; i++) {
|
|
var key = keys[i];
|
|
if (obj[key] === void 0) obj[key] = source[key];
|
|
}
|
|
}
|
|
return obj;
|
|
};
|
|
|
|
function stringify(item, options) {
|
|
var references = [];
|
|
|
|
// Backward compatibility with 0.0.6 that exepects `options` to be a callback.
|
|
options = typeof options === 'function' ? { prepare: options } : options;
|
|
options = defaults(options || {}, {
|
|
prepare: null,
|
|
isSerializable: function(item, key) {
|
|
return item.hasOwnProperty(key);
|
|
}
|
|
});
|
|
|
|
var root = cloneWithReferences(item, references, options);
|
|
|
|
return JSON.stringify({
|
|
root: root,
|
|
references: references
|
|
});
|
|
}
|
|
|
|
function cloneWithReferences(item, references, options, savedItems) {
|
|
// invoke callback before any operations related to serializing the item
|
|
if (options.prepare) { options.prepare(item); }
|
|
|
|
savedItems = savedItems || [];
|
|
var type = typeOf(item);
|
|
|
|
// can this object contain its own properties?
|
|
if (CONTAINER_TYPES.indexOf(type) !== -1) {
|
|
var referenceIndex = savedItems.indexOf(item);
|
|
// do we need to store a new reference to this object?
|
|
if (referenceIndex === -1) {
|
|
var clone = {};
|
|
referenceIndex = references.push({
|
|
contents: clone,
|
|
value: wrapConstructor(item)
|
|
}) - 1;
|
|
savedItems[referenceIndex] = item;
|
|
for (var key in item) {
|
|
if (options.isSerializable(item, key)) {
|
|
clone[key] = cloneWithReferences(item[key], references, options, savedItems);
|
|
}
|
|
}
|
|
}
|
|
|
|
// return something like _CRYO_REF_22
|
|
return REFERENCE_FLAG + referenceIndex;
|
|
}
|
|
|
|
// return a non-container object
|
|
return wrap(item);
|
|
}
|
|
|
|
function parse(string, options) {
|
|
var json = JSON.parse(string);
|
|
|
|
// Backward compatibility with 0.0.6 that exepects `options` to be a callback.
|
|
options = typeof options === 'function' ? { finalize: options } : options;
|
|
options = defaults(options || {}, { finalize: null });
|
|
|
|
return rebuildFromReferences(json.root, json.references, options);
|
|
}
|
|
|
|
function rebuildFromReferences(item, references, options, restoredItems) {
|
|
restoredItems = restoredItems || [];
|
|
if (starts(item, REFERENCE_FLAG)) {
|
|
var referenceIndex = parseInt(item.slice(REFERENCE_FLAG.length), 10);
|
|
if (!restoredItems.hasOwnProperty(referenceIndex)) {
|
|
var ref = references[referenceIndex];
|
|
var container = unwrapConstructor(ref.value);
|
|
var contents = ref.contents;
|
|
restoredItems[referenceIndex] = container;
|
|
for (var key in contents) {
|
|
container[key] = rebuildFromReferences(contents[key], references, options, restoredItems);
|
|
}
|
|
}
|
|
|
|
// invoke callback after all operations related to serializing the item
|
|
if (options.finalize) { options.finalize(restoredItems[referenceIndex]); }
|
|
|
|
return restoredItems[referenceIndex];
|
|
}
|
|
|
|
// invoke callback after all operations related to serializing the item
|
|
if (options.finalize) { options.finalize(item); }
|
|
|
|
return unwrap(item);
|
|
}
|
|
|
|
function wrap(item) {
|
|
var type = typeOf(item);
|
|
if (type === 'undefined') return UNDEFINED_FLAG;
|
|
if (type === 'function') return FUNCTION_FLAG + item.toString();
|
|
if (type === 'date') return DATE_FLAG + item.getTime();
|
|
if (item === Infinity) return INFINITY_FLAG;
|
|
if (type === 'dom') return undefined;
|
|
return item;
|
|
}
|
|
|
|
function wrapConstructor(item) {
|
|
var type = typeOf(item);
|
|
if (type === 'function' || type === 'date') return wrap(item);
|
|
if (type === 'object') return OBJECT_FLAG;
|
|
if (type === 'array') return ARRAY_FLAG;
|
|
return item;
|
|
}
|
|
|
|
function unwrapConstructor(val) {
|
|
if (typeOf(val) === 'string') {
|
|
if (val === UNDEFINED_FLAG) return undefined;
|
|
if (starts(val, FUNCTION_FLAG)) {
|
|
return (new Function("return " + val.slice(FUNCTION_FLAG.length)))();
|
|
}
|
|
if (starts(val, DATE_FLAG)) {
|
|
var dateNum = parseInt(val.slice(DATE_FLAG.length), 10);
|
|
return new Date(dateNum);
|
|
}
|
|
if (starts(val, OBJECT_FLAG)) {
|
|
return {};
|
|
}
|
|
if (starts(val, ARRAY_FLAG)) {
|
|
return [];
|
|
}
|
|
if (val === INFINITY_FLAG) return Infinity;
|
|
}
|
|
return val;
|
|
}
|
|
|
|
function unwrap(val) {
|
|
if (typeOf(val) === 'string') {
|
|
if (val === UNDEFINED_FLAG) return undefined;
|
|
if (starts(val, FUNCTION_FLAG)) {
|
|
var fn = val.slice(FUNCTION_FLAG.length);
|
|
var argStart = fn.indexOf('(') + 1;
|
|
var argEnd = fn.indexOf(')', argStart);
|
|
var args = fn.slice(argStart, argEnd);
|
|
var bodyStart = fn.indexOf('{') + 1;
|
|
var bodyEnd = fn.lastIndexOf('}') - 1;
|
|
var body = fn.slice(bodyStart, bodyEnd);
|
|
return new Function(args, body);
|
|
}
|
|
if (starts(val, DATE_FLAG)) {
|
|
var dateNum = parseInt(val.slice(DATE_FLAG.length), 10);
|
|
return new Date(dateNum);
|
|
}
|
|
if (val === INFINITY_FLAG) return Infinity;
|
|
}
|
|
return val;
|
|
}
|
|
|
|
function starts(string, prefix) {
|
|
return typeOf(string) === 'string' && string.slice(0, prefix.length) === prefix;
|
|
}
|
|
|
|
function isNumber(n) {
|
|
return !isNaN(parseFloat(n)) && isFinite(n);
|
|
}
|
|
|
|
// Exported object
|
|
var Cryo = {
|
|
stringify: stringify,
|
|
parse: parse
|
|
};
|
|
|
|
// global on server, window in browser
|
|
var root = this;
|
|
|
|
// AMD / RequireJS
|
|
if (typeof define !== 'undefined' && define.amd) {
|
|
define('Cryo', [], function () {
|
|
return Cryo;
|
|
});
|
|
}
|
|
|
|
// node.js
|
|
else if (typeof module !== 'undefined' && module.exports) {
|
|
module.exports = Cryo;
|
|
}
|
|
|
|
// included directly via <script> tag
|
|
else {
|
|
root.Cryo = Cryo;
|
|
}
|
|
|
|
})();
|
|
|
|
},{}],7:[function(require,module,exports){
|
|
exports.read = function (buffer, offset, isLE, mLen, nBytes) {
|
|
var e, m
|
|
var eLen = nBytes * 8 - mLen - 1
|
|
var eMax = (1 << eLen) - 1
|
|
var eBias = eMax >> 1
|
|
var nBits = -7
|
|
var i = isLE ? (nBytes - 1) : 0
|
|
var d = isLE ? -1 : 1
|
|
var s = buffer[offset + i]
|
|
|
|
i += d
|
|
|
|
e = s & ((1 << (-nBits)) - 1)
|
|
s >>= (-nBits)
|
|
nBits += eLen
|
|
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
|
|
|
|
m = e & ((1 << (-nBits)) - 1)
|
|
e >>= (-nBits)
|
|
nBits += mLen
|
|
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
|
|
|
|
if (e === 0) {
|
|
e = 1 - eBias
|
|
} else if (e === eMax) {
|
|
return m ? NaN : ((s ? -1 : 1) * Infinity)
|
|
} else {
|
|
m = m + Math.pow(2, mLen)
|
|
e = e - eBias
|
|
}
|
|
return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
|
|
}
|
|
|
|
exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
|
|
var e, m, c
|
|
var eLen = nBytes * 8 - mLen - 1
|
|
var eMax = (1 << eLen) - 1
|
|
var eBias = eMax >> 1
|
|
var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
|
|
var i = isLE ? 0 : (nBytes - 1)
|
|
var d = isLE ? 1 : -1
|
|
var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
|
|
|
|
value = Math.abs(value)
|
|
|
|
if (isNaN(value) || value === Infinity) {
|
|
m = isNaN(value) ? 1 : 0
|
|
e = eMax
|
|
} else {
|
|
e = Math.floor(Math.log(value) / Math.LN2)
|
|
if (value * (c = Math.pow(2, -e)) < 1) {
|
|
e--
|
|
c *= 2
|
|
}
|
|
if (e + eBias >= 1) {
|
|
value += rt / c
|
|
} else {
|
|
value += rt * Math.pow(2, 1 - eBias)
|
|
}
|
|
if (value * c >= 2) {
|
|
e++
|
|
c /= 2
|
|
}
|
|
|
|
if (e + eBias >= eMax) {
|
|
m = 0
|
|
e = eMax
|
|
} else if (e + eBias >= 1) {
|
|
m = (value * c - 1) * Math.pow(2, mLen)
|
|
e = e + eBias
|
|
} else {
|
|
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
|
|
e = 0
|
|
}
|
|
}
|
|
|
|
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
|
|
|
|
e = (e << mLen) | m
|
|
eLen += mLen
|
|
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
|
|
|
|
buffer[offset + i - d] |= s * 128
|
|
}
|
|
|
|
},{}],8:[function(require,module,exports){
|
|
module.exports = function(url = location.href.replace('http', 'ws')){
|
|
const io = emitterify({ attempt: 0 })
|
|
io.ready = io.once('connected')
|
|
io.connect = connect(io, url)
|
|
io.connect()
|
|
io.send = data => io.ready.then(socket => socket.send(data))
|
|
return io
|
|
}
|
|
|
|
const emitterify = require('utilise/emitterify')
|
|
, { min, pow } = Math
|
|
|
|
const connect = (io, url) => () => {
|
|
const { WebSocket, location, setTimeout } = window
|
|
, socket = new WebSocket(url)
|
|
socket.onopen = d => io.emit('connected', socket)
|
|
socket.onmessage = d => io.emit('recv', d.data)
|
|
socket.onclose = d => {
|
|
io.ready = io.once('connected')
|
|
io.emit('disconnected')
|
|
setTimeout(io.connect, backoff(++io.attempt))
|
|
}
|
|
}
|
|
|
|
const backoff = (attempt, base = 100, cap = 10000) =>
|
|
min(cap, base * pow(2, attempt))
|
|
},{"utilise/emitterify":20}],9:[function(require,module,exports){
|
|
// -------------------------------------------
|
|
// API: Gets or sets a resource
|
|
// -------------------------------------------
|
|
// ripple('name') - returns the resource body if it exists
|
|
// ripple('name') - creates & returns resource if it doesn't exist
|
|
// ripple('name', {}) - creates & returns resource, with specified name and body
|
|
// ripple({ ... }) - creates & returns resource, with specified name, body and headers
|
|
// ripple.resources - returns raw resources
|
|
// ripple.resource - alias for ripple, returns ripple instead of resource for method chaining
|
|
// ripple.register - alias for ripple
|
|
// ripple.on - event listener for changes - all resources
|
|
// ripple('name').on - event listener for changes - resource-specific
|
|
|
|
module.exports = function core(){
|
|
log('creating')
|
|
|
|
const resources = {}
|
|
ripple.resources = resources
|
|
ripple.resource = chainable(ripple)
|
|
ripple.register = ripple
|
|
ripple.types = types()
|
|
return emitterify(ripple)
|
|
|
|
function ripple(name, body, headers){
|
|
return !name ? ripple
|
|
: is.arr(name) ? name.map(ripple)
|
|
: is.promise(name) ? name.then(ripple).catch(err)
|
|
: is.obj(name) && !name.name ? ripple(values(name))
|
|
: is.fn(name) && name.resources ? ripple(values(name.resources))
|
|
: is.str(name) && !body && ripple.resources[name] ? ripple.resources[name].body
|
|
: is.str(name) && !body && !ripple.resources[name] ? undefined //register(ripple)({ name })
|
|
: is.str(name) && body ? register(ripple)({ name, body, headers })
|
|
: is.obj(name) && !is.arr(name) ? register(ripple)(name)
|
|
: (err('could not find or create resource', name), false)
|
|
}
|
|
}
|
|
|
|
const register = ripple => ({name, body, headers = {}}) => {
|
|
log('registering', name)
|
|
if (is.promise(body)) return body.then(body => register(ripple)({ name, body, headers })).catch(err)
|
|
const res = normalise(ripple)({ name, body, headers })
|
|
|
|
if (!res) return err('failed to register', name), false
|
|
ripple.resources[name] = res
|
|
ripple.emit('change', [name, {
|
|
type: 'update'
|
|
, value: res.body
|
|
, time: now(res)
|
|
}])
|
|
return ripple.resources[name].body
|
|
}
|
|
|
|
const normalise = ripple => res => {
|
|
if (!header('content-type')(res)) values(ripple.types).sort(za('priority')).some(contentType(res))
|
|
if (!header('content-type')(res)) return err('could not understand resource', res), false
|
|
return parse(ripple)(res)
|
|
}
|
|
|
|
const parse = ripple => res => {
|
|
var type = header('content-type')(res)
|
|
if (!ripple.types[type]) return err('could not understand type', type), false
|
|
return (ripple.types[type].parse || identity)(res)
|
|
}
|
|
|
|
const contentType = res => type => type.check(res) && (res.headers['content-type'] = type.header)
|
|
|
|
const types = () => [text].reduce(to.obj('header'), 1)
|
|
|
|
const chainable = fn => function() {
|
|
return fn.apply(this, arguments), fn
|
|
}
|
|
|
|
const emitterify = require('utilise/emitterify')
|
|
, colorfill = require('utilise/colorfill')
|
|
, identity = require('utilise/identity')
|
|
, header = require('utilise/header')
|
|
, values = require('utilise/values')
|
|
, key = require('utilise/key')
|
|
, is = require('utilise/is')
|
|
, to = require('utilise/to')
|
|
, za = require('utilise/za')
|
|
, text = require('./types/text')
|
|
, err = require('utilise/err')('[ri/core]')
|
|
, log = require('utilise/log')('[ri/core]')
|
|
, now = (d, t) => (t = key('body.log.length')(d), is.num(t) ? t - 1 : t)
|
|
},{"./types/text":10,"utilise/colorfill":15,"utilise/emitterify":20,"utilise/err":21,"utilise/header":28,"utilise/identity":29,"utilise/is":31,"utilise/key":32,"utilise/log":34,"utilise/to":43,"utilise/values":44,"utilise/za":46}],10:[function(require,module,exports){
|
|
module.exports = {
|
|
header: 'text/plain'
|
|
, check(res){ return !includes('.html')(res.name) && !includes('.css')(res.name) && is.str(res.body) }
|
|
}
|
|
|
|
const includes = require('utilise/includes')
|
|
, is = require('utilise/is')
|
|
},{"utilise/includes":30,"utilise/is":31}],11:[function(require,module,exports){
|
|
// -------------------------------------------
|
|
// Adds support for data resources
|
|
// -------------------------------------------
|
|
module.exports = function data(ripple){
|
|
log('creating')
|
|
ripple
|
|
.on('change.data')
|
|
.filter(([name, change]) => header('content-type', 'application/data')(ripple.resources[name]))
|
|
.filter(([name, change]) => change && change.key)
|
|
.map(([name, change]) => ripple
|
|
.resources[name]
|
|
.body
|
|
.emit('change', (change || null), not(is.in(['bubble']))))
|
|
|
|
ripple.types['application/data'] = {
|
|
header: 'application/data'
|
|
, selector: res => `[data~="${res.name}"]`
|
|
, extract: el => (attr(`data`)(el) || '').split(' ')
|
|
, check: res => is.obj(res.body) ? true : false
|
|
, parse(res){
|
|
if (is.str(res.body)) res.body = fn(res.body)
|
|
const existing = ripple.resources[res.name] || {}
|
|
|
|
extend(res.headers)(existing.headers)
|
|
res.body = set()(
|
|
res.body || []
|
|
, existing.body && existing.body.log
|
|
, is.num(res.headers.log) ? res.headers.log : -1
|
|
)
|
|
overwrite(res.body.on)(listeners(existing))
|
|
res.body.on('change.bubble', change => {
|
|
ripple.emit('change', ripple.change = [res.name, change], not(is.in(['data'])))
|
|
delete ripple.change
|
|
})
|
|
|
|
return res
|
|
}
|
|
}
|
|
|
|
return ripple
|
|
}
|
|
|
|
const overwrite = require('utilise/overwrite')
|
|
, header = require('utilise/header')
|
|
, extend = require('utilise/extend')
|
|
, attr = require('utilise/attr')
|
|
, not = require('utilise/not')
|
|
, key = require('utilise/key')
|
|
, set = require('utilise/set')
|
|
, fn = require('utilise/fn')
|
|
, is = require('utilise/is')
|
|
, log = require('utilise/log')('[ri/types/data]')
|
|
, listeners = key('body.on')
|
|
},{"utilise/attr":13,"utilise/extend":23,"utilise/fn":25,"utilise/header":28,"utilise/is":31,"utilise/key":32,"utilise/log":34,"utilise/not":36,"utilise/overwrite":37,"utilise/set":41}],12:[function(require,module,exports){
|
|
(function (Buffer){
|
|
module.exports = function sync(
|
|
ripple
|
|
, {} = {}
|
|
, { xrs = require('xrs/client') } = {}
|
|
){
|
|
ripple.send = send(xrs())
|
|
ripple.subscribe = subscribe(ripple)
|
|
ripple.subscriptions = {}
|
|
ripple.get = get(ripple)
|
|
ripple.upload = upload(ripple)
|
|
ripple.upload.id = 0
|
|
ripple.render = render(ripple)(ripple.render)
|
|
ripple.deps = deps(ripple)
|
|
return ripple
|
|
}
|
|
|
|
const send = xrs => (name, type, value) =>
|
|
name instanceof Blob ? xrs(name, type)
|
|
: is.obj(name) ? xrs(name)
|
|
: xrs({ name, type, value })
|
|
|
|
const get = ripple => (name, k) => {
|
|
ripple.subscriptions[name] = ripple.subscriptions[name] || {}
|
|
if (is.arr(k)) return Promise.all(k.map(k => ripple.get(name, k)))
|
|
const existing = key(k)(key(`resources.${name}.body`)(ripple))
|
|
|
|
return k in ripple.subscriptions[name] && existing
|
|
? Promise.resolve(existing)
|
|
: ripple
|
|
.subscribe(name, k)
|
|
.filter((d, i, n) => n.source.emit('stop'))
|
|
.map(d => key(k)(key(`resources.${name}.body`)(ripple)))
|
|
}
|
|
|
|
const cache = (ripple, name, key) => change => {
|
|
if (key) change.key = `${key}.${change.key}`
|
|
!change.key && change.type == 'update'
|
|
? ripple(body(extend({ name })(change)))
|
|
: set(change)(name in ripple.resources ? ripple(name) : ripple(name, {}))
|
|
|
|
return change
|
|
}
|
|
|
|
// TODO: factor out
|
|
const merge = streams => {
|
|
const output = emitterify().on('next')
|
|
, latest = []
|
|
|
|
streams.map(($, i) =>
|
|
$.each(value => {
|
|
latest[i] = value
|
|
output.next(latest)
|
|
})
|
|
)
|
|
|
|
output
|
|
.once('stop')
|
|
.map(d => streams.map($ => $.source.emit('stop')))
|
|
|
|
return output
|
|
}
|
|
|
|
const subscribe = ripple => (name, k) => {
|
|
if (is.arr(name)) return merge(name.map(n => ripple.subscribe(n, k)))
|
|
ripple.subscriptions[name] = ripple.subscriptions[name] || {}
|
|
if (is.arr(k)) return merge(k.map(k => ripple.subscribe(name, k))).map(d => key(k)(ripple(name))) // merge(ripple, name, k)
|
|
const output = emitterify().on('next')
|
|
|
|
output
|
|
.on('stop')
|
|
.filter(() => raw.off(output.next) && !raw.li.length)
|
|
.map(() => raw.source.emit('stop'))
|
|
.map(() => { ripple.subscriptions[name][k] = undefined })
|
|
|
|
if (ripple.subscriptions[name][k])
|
|
output
|
|
.on('start')
|
|
.map(() => key(k)(ripple(name)))
|
|
.filter(is.def)
|
|
.map(initial => output.next(initial))
|
|
|
|
const raw = ripple.subscriptions[name][k] = ripple.subscriptions[name][k] || ripple
|
|
.send(name, 'SUBSCRIBE', k)
|
|
.map(cache(ripple, name, k))
|
|
.map(d => key(k)(ripple(name)))
|
|
// .reduce((acc = {}, d, i) => i ? set(d)(acc) : d.value)
|
|
|
|
raw.each(output.next)
|
|
|
|
return output
|
|
}
|
|
|
|
const upload = ripple => (name, form) => {
|
|
let index = ++ripple.upload.id
|
|
, fields = {}
|
|
, size = 0
|
|
, next = () => {
|
|
if (!files.length) return true
|
|
const { field, filename, i, blob } = files.shift()
|
|
return ripple
|
|
.send(blob, { filename, field, i, index })
|
|
.on('progress', ({ received, total }) => output.emit('progress', {
|
|
total: size
|
|
, received:
|
|
size
|
|
- (blob.size - received)
|
|
- files.reduce((acc, d) => (acc += d.blob.size), 0)
|
|
}))
|
|
.then(next)
|
|
}
|
|
|
|
const files = keys(form)
|
|
.map(field => (fields[field] = form[field], field))
|
|
.filter(field => form[field] instanceof FileList)
|
|
.map(field => {
|
|
fields[field] = []
|
|
return to.arr(form[field])
|
|
.map(f => (size += f.size, f))
|
|
.map((f, i) => ({ field, filename: f.name, i, blob: f, sent: 0 }))
|
|
})
|
|
.reduce(flatten, [])
|
|
|
|
const output = ripple.send({
|
|
files: files.length
|
|
, type: 'PREUPLOAD'
|
|
, fields
|
|
, index
|
|
, size
|
|
, name
|
|
}).once('sent', next)
|
|
|
|
return output
|
|
}
|
|
|
|
const body = ({ name, value, headers }) => ({ name, headers, body: value })
|
|
|
|
const render = ripple => next => el => ripple.deps(el)
|
|
.filter(not(is.in(ripple.subscriptions)))
|
|
.map(dep => ripple
|
|
.subscribe(dep)
|
|
// TOOO: Should be .until(el.once('removed'))
|
|
// .filter(d => !all(el.nodeName).length)
|
|
// .map((d, i, n) => n.source.unsubscribe())
|
|
)
|
|
.length ? false : next(el)
|
|
|
|
const deps = ripple => el => values(ripple.types)
|
|
.filter(d => d.extract)
|
|
.map(d => d.extract(el))
|
|
.reduce((p, v) => p.concat(v), [])
|
|
.filter(Boolean)
|
|
|
|
const is = require('utilise/is')
|
|
, to = require('utilise/to')
|
|
, set = require('utilise/set')
|
|
, not = require('utilise/not')
|
|
, key = require('utilise/key')
|
|
, keys = require('utilise/keys')
|
|
, flatten = require('utilise/flatten')
|
|
, extend = require('utilise/extend')
|
|
, values = require('utilise/values')
|
|
, emitterify = require('utilise/emitterify')
|
|
, all = node => arr(document.querySelectorAll(node))
|
|
, { min, pow } = Math
|
|
, nametype = (name, type) => `(${name ? name + ', ' : ''}${type ? type : ''})`
|
|
, stream = chunks => new require('stream').Readable({
|
|
read(){
|
|
this.push(chunks.length ? new Buffer(new Uint8Array(chunks.shift())) : null)
|
|
}
|
|
})
|
|
}).call(this,require("buffer").Buffer)
|
|
},{"buffer":4,"utilise/emitterify":20,"utilise/extend":23,"utilise/flatten":24,"utilise/is":31,"utilise/key":32,"utilise/keys":33,"utilise/not":36,"utilise/set":41,"utilise/to":43,"utilise/values":44,"xrs/client":47}],13:[function(require,module,exports){
|
|
var is = require('./is')
|
|
|
|
module.exports = function attr(name, value) {
|
|
var args = arguments.length
|
|
|
|
return !is.str(name) && args == 2 ? attr(arguments[1]).call(this, arguments[0])
|
|
: !is.str(name) && args == 3 ? attr(arguments[1], arguments[2]).call(this, arguments[0])
|
|
: function(el){
|
|
var ctx = this || {}
|
|
el = ctx.nodeName || is.fn(ctx.node) ? ctx : el
|
|
el = el.node ? el.node() : el
|
|
el = el.host || el
|
|
|
|
return args > 1 && value === false ? el.removeAttribute(name)
|
|
: args > 1 ? (el.setAttribute(name, value), value)
|
|
: el.attributes.getNamedItem(name)
|
|
&& el.attributes.getNamedItem(name).value
|
|
}
|
|
}
|
|
|
|
},{"./is":31}],14:[function(require,module,exports){
|
|
module.exports = typeof window != 'undefined'
|
|
},{}],15:[function(require,module,exports){
|
|
var client = require('./client')
|
|
, colors = !client && require('colors')
|
|
, has = require('./has')
|
|
, is = require('./is')
|
|
|
|
module.exports = colorfill()
|
|
|
|
function colorfill(){
|
|
/* istanbul ignore next */
|
|
['red', 'green', 'bold', 'grey', 'strip'].forEach(function(color) {
|
|
!is.str(String.prototype[color]) && Object.defineProperty(String.prototype, color, {
|
|
get: function() {
|
|
return String(this)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
|
|
},{"./client":14,"./has":27,"./is":31,"colors":3}],16:[function(require,module,exports){
|
|
module.exports = function copy(from, to){
|
|
return function(d){
|
|
return to[d] = from[d], d
|
|
}
|
|
}
|
|
},{}],17:[function(require,module,exports){
|
|
module.exports = function datum(node){
|
|
return node.__data__
|
|
}
|
|
},{}],18:[function(require,module,exports){
|
|
var is = require('./is')
|
|
|
|
module.exports = function debounce(d){
|
|
var pending, wait = is.num(d) ? d : 100
|
|
|
|
return is.fn(d)
|
|
? next(d)
|
|
: next
|
|
|
|
function next(fn){
|
|
return function(){
|
|
var ctx = this, args = arguments
|
|
pending && clearTimeout(pending)
|
|
pending = setTimeout(function(){ fn.apply(ctx, args) }, wait)
|
|
}
|
|
}
|
|
|
|
}
|
|
},{"./is":31}],19:[function(require,module,exports){
|
|
var has = require('./has')
|
|
|
|
module.exports = function def(o, p, v, w){
|
|
if (o.host && o.host.nodeName) o = o.host
|
|
if (p.name) v = p, p = p.name
|
|
!has(o, p) && Object.defineProperty(o, p, { value: v, writable: w })
|
|
return o[p]
|
|
}
|
|
|
|
},{"./has":27}],20:[function(require,module,exports){
|
|
var promise = require('./promise')
|
|
, flatten = require('./flatten')
|
|
, def = require('./def')
|
|
|
|
module.exports = function emitterify(body) {
|
|
body = body || {}
|
|
def(body, 'emit', emit, 1)
|
|
def(body, 'once', once, 1)
|
|
def(body, 'off', off, 1)
|
|
def(body, 'on', on, 1)
|
|
body.on['*'] = body.on['*'] || []
|
|
return body
|
|
|
|
function emit(type, pm, filter) {
|
|
var li = body.on[type.split('.')[0]] || []
|
|
, results = []
|
|
|
|
for (var i = 0; i < li.length; i++)
|
|
if (!li[i].ns || !filter || filter(li[i].ns))
|
|
results.push(call(li[i].isOnce ? li.splice(i--, 1)[0] : li[i], pm))
|
|
|
|
for (var i = 0; i < body.on['*'].length; i++)
|
|
results.push(call(body.on['*'][i], [type, pm]))
|
|
|
|
return results.reduce(flatten, [])
|
|
}
|
|
|
|
function call(cb, pm){
|
|
return cb.next ? cb.next(pm)
|
|
: pm instanceof Array ? cb.apply(body, pm)
|
|
: cb.call(body, pm)
|
|
}
|
|
|
|
function on(type, opts, isOnce) {
|
|
var id = type.split('.')[0]
|
|
, ns = type.split('.')[1]
|
|
, li = body.on[id] = body.on[id] || []
|
|
, cb = typeof opts == 'function' ? opts : 0
|
|
|
|
return !cb && ns ? (cb = body.on[id]['$'+ns]) ? cb : push(observable(body, opts))
|
|
: !cb && !ns ? push(observable(body, opts))
|
|
: cb && ns ? push((remove(li, body.on[id]['$'+ns] || -1), cb))
|
|
: cb && !ns ? push(cb)
|
|
: false
|
|
|
|
function push(cb){
|
|
cb.isOnce = isOnce
|
|
cb.type = id
|
|
if (ns) body.on[id]['$'+(cb.ns = ns)] = cb
|
|
li.push(cb)
|
|
return cb.next ? cb : body
|
|
}
|
|
}
|
|
|
|
function once(type, callback){
|
|
return body.on(type, callback, true)
|
|
}
|
|
|
|
function remove(li, cb) {
|
|
var i = li.length
|
|
while (~--i)
|
|
if (cb == li[i] || cb == li[i].fn || !cb)
|
|
li.splice(i, 1)
|
|
}
|
|
|
|
function off(type, cb) {
|
|
remove((body.on[type] || []), cb)
|
|
if (cb && cb.ns) delete body.on[type]['$'+cb.ns]
|
|
return body
|
|
}
|
|
|
|
function observable(parent, opts) {
|
|
opts = opts || {}
|
|
var o = emitterify(opts.base || promise())
|
|
o.i = 0
|
|
o.li = []
|
|
o.fn = opts.fn
|
|
o.parent = parent
|
|
o.source = opts.fn ? o.parent.source : o
|
|
|
|
o.on('stop', function(reason){
|
|
return o.type
|
|
? o.parent.off(o.type, o)
|
|
: o.parent.off(o)
|
|
})
|
|
|
|
o.each = function(fn) {
|
|
var n = fn.next ? fn : observable(o, { fn: fn })
|
|
o.li.push(n)
|
|
return n
|
|
}
|
|
|
|
o.pipe = function(fn) {
|
|
return fn(o)
|
|
}
|
|
|
|
o.map = function(fn){
|
|
return o.each(function(d, i, n){ return n.next(fn(d, i, n)) })
|
|
}
|
|
|
|
o.filter = function(fn){
|
|
return o.each(function(d, i, n){ return fn(d, i, n) && n.next(d) })
|
|
}
|
|
|
|
o.reduce = function(fn, acc) {
|
|
return o.each(function(d, i, n){ return n.next(acc = fn(acc, d, i, n)) })
|
|
}
|
|
|
|
o.unpromise = function(){
|
|
var n = observable(o, { base: {}, fn: function(d){ return n.next(d) } })
|
|
o.li.push(n)
|
|
return n
|
|
}
|
|
|
|
o.next = function(value) {
|
|
o.resolve && o.resolve(value)
|
|
return o.li.length
|
|
? o.li.map(function(n){ return n.fn(value, n.i++, n) })
|
|
: value
|
|
}
|
|
|
|
o.until = function(stop){
|
|
stop.each(function(){ o.source.emit('stop') })
|
|
return o
|
|
}
|
|
|
|
o.off = function(fn){
|
|
return remove(o.li, fn), o
|
|
}
|
|
|
|
o[Symbol.asyncIterator] = function(){
|
|
return {
|
|
next: function(){
|
|
return o.wait = new Promise(function(resolve){
|
|
o.wait = true
|
|
o.map(function(d, i, n){
|
|
delete o.wait
|
|
o.off(n)
|
|
resolve({ value: d, done: false })
|
|
})
|
|
o.emit('pull', o)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
return o
|
|
}
|
|
}
|
|
},{"./def":19,"./flatten":24,"./promise":39}],21:[function(require,module,exports){
|
|
var is = require('./is')
|
|
, to = require('./to')
|
|
, owner = require('./owner')
|
|
|
|
module.exports = function err(ns){
|
|
return function(d){
|
|
if (!owner.console || !console.error.apply) return d;
|
|
is.arr(arguments[2]) && (arguments[2] = arguments[2].length)
|
|
var args = to.arr(arguments)
|
|
, prefix = '[err][' + (new Date()).toISOString() + ']' + ns
|
|
|
|
args.unshift(prefix.red ? prefix.red : prefix)
|
|
return console.error.apply(console, args), d
|
|
}
|
|
}
|
|
},{"./is":31,"./owner":38,"./to":43}],22:[function(require,module,exports){
|
|
module.exports = function escape(str) {
|
|
return str.replace(/[&<>'"]/g, function(char){
|
|
return safe[char]
|
|
})
|
|
}
|
|
|
|
var safe = {
|
|
"&": "&"
|
|
, "<": "<"
|
|
, ">": ">"
|
|
, '"': """
|
|
, "'": "'"
|
|
}
|
|
|
|
},{}],23:[function(require,module,exports){
|
|
var is = require('./is')
|
|
, not = require('./not')
|
|
, keys = require('./keys')
|
|
, copy = require('./copy')
|
|
|
|
module.exports = function extend(to){
|
|
return function(from){
|
|
keys(from)
|
|
.filter(not(is.in(to)))
|
|
.map(copy(from, to))
|
|
|
|
return to
|
|
}
|
|
}
|
|
},{"./copy":16,"./is":31,"./keys":33,"./not":36}],24:[function(require,module,exports){
|
|
module.exports = function flatten(p,v){
|
|
if (v instanceof Array) v = v.reduce(flatten, [])
|
|
return (p = p || []), p.concat(v)
|
|
}
|
|
|
|
},{}],25:[function(require,module,exports){
|
|
var is = require('./is')
|
|
|
|
module.exports = function fn(candid){
|
|
return is.fn(candid) ? candid
|
|
: (new Function("return " + candid))()
|
|
}
|
|
},{"./is":31}],26:[function(require,module,exports){
|
|
var datum = require('./datum')
|
|
, key = require('./key')
|
|
|
|
module.exports = from
|
|
from.parent = fromParent
|
|
|
|
function from(o){
|
|
return function(k){
|
|
return key(k)(o)
|
|
}
|
|
}
|
|
|
|
function fromParent(k){
|
|
return datum(this.parentNode)[k]
|
|
}
|
|
},{"./datum":17,"./key":32}],27:[function(require,module,exports){
|
|
module.exports = function has(o, k) {
|
|
return k in o
|
|
}
|
|
},{}],28:[function(require,module,exports){
|
|
var key = require('./key')
|
|
|
|
module.exports = function header(header, value) {
|
|
var getter = arguments.length == 1
|
|
return function(d){
|
|
return !d || !d.headers ? null
|
|
: getter ? key(header)(d.headers)
|
|
: key(header)(d.headers) == value
|
|
}
|
|
}
|
|
},{"./key":32}],29:[function(require,module,exports){
|
|
module.exports = function identity(d) {
|
|
return d
|
|
}
|
|
},{}],30:[function(require,module,exports){
|
|
module.exports = function includes(pattern){
|
|
return function(d){
|
|
return d && d.indexOf && ~d.indexOf(pattern)
|
|
}
|
|
}
|
|
},{}],31:[function(require,module,exports){
|
|
module.exports = is
|
|
is.fn = isFunction
|
|
is.str = isString
|
|
is.num = isNumber
|
|
is.obj = isObject
|
|
is.lit = isLiteral
|
|
is.bol = isBoolean
|
|
is.truthy = isTruthy
|
|
is.falsy = isFalsy
|
|
is.arr = isArray
|
|
is.null = isNull
|
|
is.def = isDef
|
|
is.in = isIn
|
|
is.promise = isPromise
|
|
is.stream = isStream
|
|
|
|
function is(v){
|
|
return function(d){
|
|
return d == v
|
|
}
|
|
}
|
|
|
|
function isFunction(d) {
|
|
return typeof d == 'function'
|
|
}
|
|
|
|
function isBoolean(d) {
|
|
return typeof d == 'boolean'
|
|
}
|
|
|
|
function isString(d) {
|
|
return typeof d == 'string'
|
|
}
|
|
|
|
function isNumber(d) {
|
|
return typeof d == 'number'
|
|
}
|
|
|
|
function isObject(d) {
|
|
return typeof d == 'object'
|
|
}
|
|
|
|
function isLiteral(d) {
|
|
return d.constructor == Object
|
|
}
|
|
|
|
function isTruthy(d) {
|
|
return !!d == true
|
|
}
|
|
|
|
function isFalsy(d) {
|
|
return !!d == false
|
|
}
|
|
|
|
function isArray(d) {
|
|
return d instanceof Array
|
|
}
|
|
|
|
function isNull(d) {
|
|
return d === null
|
|
}
|
|
|
|
function isDef(d) {
|
|
return typeof d !== 'undefined'
|
|
}
|
|
|
|
function isPromise(d) {
|
|
return d instanceof Promise
|
|
}
|
|
|
|
function isStream(d) {
|
|
return !!(d && d.next)
|
|
}
|
|
|
|
function isIn(set) {
|
|
return function(d){
|
|
return !set ? false
|
|
: set.indexOf ? ~set.indexOf(d)
|
|
: d in set
|
|
}
|
|
}
|
|
},{}],32:[function(require,module,exports){
|
|
var wrap = require('./wrap')
|
|
, dir = require('./keys')
|
|
, str = require('./str')
|
|
, is = require('./is')
|
|
|
|
module.exports = function key(k, v){
|
|
var set = arguments.length > 1
|
|
, keys = is.fn(k) ? [] : str(k).split('.').filter(Boolean)
|
|
, root = keys.shift()
|
|
|
|
return function deep(o, i){
|
|
var masked = {}
|
|
|
|
return !o ? undefined
|
|
: !is.num(k) && !k ? (set ? replace(o, v) : o)
|
|
: is.arr(k) ? (k.map(copy), masked)
|
|
: o[k] || !keys.length ? (set ? ((o[k] = is.fn(v) ? v(o[k], i) : v), o)
|
|
: (is.fn(k) ? k(o) : o[k]))
|
|
: (set ? (key(keys.join('.'), v)(o[root] ? o[root] : (o[root] = {})), o)
|
|
: key(keys.join('.'))(o[root]))
|
|
|
|
function copy(k){
|
|
var val = key(k)(o)
|
|
if (val != undefined)
|
|
key(k, is.fn(val) ? wrap(val) : val)(masked)
|
|
}
|
|
|
|
function replace(o, v) {
|
|
dir(o).map(function(k){ delete o[k] })
|
|
dir(v).map(function(k){ o[k] = v[k] })
|
|
return o
|
|
}
|
|
}
|
|
}
|
|
},{"./is":31,"./keys":33,"./str":42,"./wrap":45}],33:[function(require,module,exports){
|
|
var is = require('./is')
|
|
|
|
module.exports = function keys(o) {
|
|
return Object.keys(is.obj(o) || is.fn(o) ? o : {})
|
|
}
|
|
},{"./is":31}],34:[function(require,module,exports){
|
|
var is = require('./is')
|
|
, to = require('./to')
|
|
, owner = require('./owner')
|
|
|
|
module.exports = function log(ns){
|
|
return function(d){
|
|
if (!owner.console || !console.log.apply) return d;
|
|
is.arr(arguments[2]) && (arguments[2] = arguments[2].length)
|
|
var args = to.arr(arguments)
|
|
, prefix = '[log][' + (new Date()).toISOString() + ']' + ns
|
|
|
|
args.unshift(prefix.grey ? prefix.grey : prefix)
|
|
return console.log.apply(console, args), d
|
|
}
|
|
}
|
|
},{"./is":31,"./owner":38,"./to":43}],35:[function(require,module,exports){
|
|
module.exports = function noop(){}
|
|
},{}],36:[function(require,module,exports){
|
|
module.exports = function not(fn){
|
|
return function(){
|
|
return !fn.apply(this, arguments)
|
|
}
|
|
}
|
|
},{}],37:[function(require,module,exports){
|
|
var is = require('./is')
|
|
, keys = require('./keys')
|
|
, copy = require('./copy')
|
|
|
|
module.exports = function overwrite(to){
|
|
return function(from){
|
|
keys(from)
|
|
.map(copy(from, to))
|
|
|
|
return to
|
|
}
|
|
}
|
|
},{"./copy":16,"./is":31,"./keys":33}],38:[function(require,module,exports){
|
|
(function (global){
|
|
var client = require('./client')
|
|
module.exports = client ? /* istanbul ignore next */ window : global
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"./client":14}],39:[function(require,module,exports){
|
|
module.exports = promise
|
|
|
|
function promise() {
|
|
var resolve
|
|
, reject
|
|
, p = new Promise(function(res, rej){
|
|
resolve = res, reject = rej
|
|
})
|
|
|
|
arguments.length && resolve(arguments[0])
|
|
p.resolve = resolve
|
|
p.reject = reject
|
|
return p
|
|
}
|
|
},{}],40:[function(require,module,exports){
|
|
module.exports = function raw(selector, doc){
|
|
var prefix = !doc && document.head.createShadowRoot ? 'html /deep/ ' : ''
|
|
return (doc ? doc : document).querySelector(prefix+selector)
|
|
}
|
|
},{}],41:[function(require,module,exports){
|
|
var act = { add: add, update: update, remove: remove }
|
|
, emitterify = require('./emitterify')
|
|
, def = require('./def')
|
|
, is = require('./is')
|
|
, str = JSON.stringify
|
|
, parse = JSON.parse
|
|
|
|
module.exports = function set(d, skipEmit) {
|
|
return function(o, existing, max) {
|
|
if (!is.obj(o) && !is.fn(o))
|
|
return o
|
|
|
|
if (!is.obj(d)) {
|
|
var log = existing || o.log || []
|
|
, root = o
|
|
|
|
if (!is.def(max)) max = log.max || 0
|
|
if (!max) log = []
|
|
if (max < 0) log = log.concat(null)
|
|
if (max > 0) {
|
|
var s = str(o)
|
|
root = parse(s)
|
|
log = log.concat({ type: 'update', value: parse(s), time: log.length })
|
|
}
|
|
|
|
def(log, 'max', max)
|
|
|
|
root.log
|
|
? (root.log = log)
|
|
: def(emitterify(root, null), 'log', log, 1)
|
|
|
|
return root
|
|
}
|
|
|
|
if (is.def(d.key)) {
|
|
if (!apply(o, d.type, (d.key = '' + d.key).split('.').filter(Boolean), d.value))
|
|
return false
|
|
} else
|
|
return false
|
|
|
|
if (o.log && o.log.max)
|
|
o.log.push((d.time = o.log.length, o.log.max > 0 ? d : null))
|
|
|
|
if (!skipEmit && o.emit)
|
|
o.emit('change', d)
|
|
|
|
return o
|
|
}
|
|
}
|
|
|
|
function apply(body, type, path, value) {
|
|
var next = path.shift()
|
|
|
|
if (!act[type])
|
|
return false
|
|
if (path.length) {
|
|
if (!(next in body))
|
|
if (type == 'remove') return true
|
|
else body[next] = {}
|
|
return apply(body[next], type, path, value)
|
|
}
|
|
else {
|
|
return !act[type](body, next, value)
|
|
}
|
|
}
|
|
|
|
function add(o, k, v) {
|
|
is.arr(o)
|
|
? o.splice(k, 0, v)
|
|
: (o[k] = v)
|
|
}
|
|
|
|
function update(o, k, v) {
|
|
if (!is.num(k) && !k) {
|
|
if (!is.obj(v)) return true
|
|
for (var x in o) delete o[x]
|
|
for (var x in v) o[x] = v[x]
|
|
} else
|
|
o[k] = v
|
|
}
|
|
|
|
function remove(o, k, v) {
|
|
is.arr(o)
|
|
? o.splice(k, 1)
|
|
: delete o[k]
|
|
}
|
|
},{"./def":19,"./emitterify":20,"./is":31}],42:[function(require,module,exports){
|
|
var is = require('./is')
|
|
|
|
module.exports = function str(d){
|
|
return d === 0 ? '0'
|
|
: !d ? ''
|
|
: is.fn(d) ? '' + d
|
|
: is.obj(d) ? JSON.stringify(d)
|
|
: String(d)
|
|
}
|
|
},{"./is":31}],43:[function(require,module,exports){
|
|
var is = require('./is')
|
|
|
|
module.exports = {
|
|
arr: toArray
|
|
, obj: toObject
|
|
}
|
|
|
|
function toArray(d){
|
|
return Array.prototype.slice.call(d, 0)
|
|
}
|
|
|
|
function toObject(d) {
|
|
var by = 'id'
|
|
, o = {}
|
|
|
|
return arguments.length == 1
|
|
? (by = d, reduce)
|
|
: reduce.apply(this, arguments)
|
|
|
|
function reduce(p,v,i){
|
|
if (i === 0) p = {}
|
|
p[is.fn(by) ? by(v, i) : v[by]] = v
|
|
return p
|
|
}
|
|
}
|
|
},{"./is":31}],44:[function(require,module,exports){
|
|
var keys = require('./keys')
|
|
, from = require('./from')
|
|
|
|
module.exports = function values(o) {
|
|
return !o ? [] : keys(o).map(from(o))
|
|
}
|
|
},{"./from":26,"./keys":33}],45:[function(require,module,exports){
|
|
module.exports = function wrap(d){
|
|
return function(){
|
|
return d
|
|
}
|
|
}
|
|
},{}],46:[function(require,module,exports){
|
|
var key = require('./key')
|
|
|
|
module.exports = function za(k) {
|
|
return function(a, b){
|
|
var ka = key(k)(a) || ''
|
|
, kb = key(k)(b) || ''
|
|
|
|
return ka > kb ? -1
|
|
: ka < kb ? 1
|
|
: 0
|
|
}
|
|
}
|
|
|
|
},{"./key":32}],47:[function(require,module,exports){
|
|
module.exports = function({
|
|
socket = require('nanosocket')()
|
|
} = {}){
|
|
socket.id = 0
|
|
|
|
socket
|
|
.once('disconnected')
|
|
.map(d => socket
|
|
.on('connected')
|
|
.map(reconnect(socket))
|
|
)
|
|
|
|
socket
|
|
.on('recv')
|
|
.map(d => parse(d))
|
|
.each(({ id, data }) => data.exec
|
|
? data.exec(socket.on[`$${id}`] && socket.on[`$${id}`][0], data.value)
|
|
: socket.emit(`$${id}`, data)
|
|
)
|
|
|
|
return Object.defineProperty(send(socket)
|
|
, 'subscriptions'
|
|
, { get: d => subscriptions(socket) }
|
|
)
|
|
}
|
|
|
|
const subscriptions = socket => values(socket.on)
|
|
.map(d => d && d[0])
|
|
.filter(d => d && d.type && d.type[0] == '$')
|
|
|
|
const reconnect = socket => () => subscriptions(socket)
|
|
.map(d => d.type)
|
|
.map(d => socket.send(socket.on[d][0].subscription))
|
|
|
|
const emitterify = require('utilise/emitterify')
|
|
, values = require('utilise/values')
|
|
, str = require('utilise/str')
|
|
, { parse } = require('cryonic')
|
|
|
|
const send = (socket, type) => (data, meta) => {
|
|
if (data instanceof window.Blob)
|
|
return binary(socket, data, meta)
|
|
|
|
const id = str(++socket.id)
|
|
, output = socket.on(`$${id}`)
|
|
, next = (data, count = 0) => socket
|
|
.send(output.source.subscription = str({ id, data, type }))
|
|
.then(d => output.emit('sent', { id, count }))
|
|
|
|
data.next
|
|
? data.map(next).source.emit('start')
|
|
: next(data)
|
|
|
|
output
|
|
.source
|
|
.once('stop')
|
|
.filter(reason => reason != 'CLOSED')
|
|
.map(d => send(socket, 'UNSUBSCRIBE')(id)
|
|
.filter((d, i, n) => n.source.emit('stop', 'CLOSED'))
|
|
)
|
|
|
|
return output
|
|
}
|
|
|
|
const binary = (socket, blob, meta, start = 0, blockSize = 1024) => {
|
|
const output = emitterify().on('recv')
|
|
, next = id => () =>
|
|
start >= blob.size
|
|
? output.emit('sent', { id })
|
|
: ( socket.send(blob.slice(start, start += blockSize))
|
|
, window.setTimeout(next(id))
|
|
)
|
|
|
|
send(socket, 'BINARY')({ size: blob.size, meta })
|
|
.on('sent', ({ id }) => next(id)())
|
|
.on('progress', received => output.emit('progress', { received, total: blob.size }))
|
|
.map(output.next)
|
|
.source
|
|
.until(output.once('stop'))
|
|
|
|
return output
|
|
}
|
|
},{"cryonic":6,"nanosocket":8,"utilise/emitterify":20,"utilise/str":42,"utilise/values":44}]},{},[1]);
|